From 146f554634a117a48fb9c0815ffdc418955a9063 Mon Sep 17 00:00:00 2001
From: Jason Ginchereau <jasongin@microsoft.com>
Date: Mon, 20 Mar 2017 14:55:26 -0700
Subject: [PATCH 001/183] n-api: add support for abi stable module API

Add support for abi stable module API (N-API) as "Experimental feature".
The goal of this API is to provide a stable Node API for native
module developers. N-API aims to provide ABI compatibility guarantees
across different Node versions and also across different
Node VMs - allowing N-API enabled native modules to just work
across different versions and flavors of Node.js without recompilation.

A more detailed introduction is provided in:
https://github.com/nodejs/node-eps/blob/master/005-ABI-Stable-Module-API.md
and https://github.com/nodejs/abi-stable-node/blob/doc/VM%20Summit.pdf.

The feature, during its experimental state, will be guarded by a runtime
flag "--napi-modules". Only when this flag is added to the command line
will N-API modules along with regular non N-API modules be supported.

The API is defined by the methods in "src/node_api.h" and
"src/node_api_types.h". This is the best
starting point to review the API surface. More documentation will follow.

In addition to the implementation of the API using V8, which is included
in this PR, the API has also been validated against chakracore and that
port is available in
https://github.com/nodejs/abi-stable-node/tree/api-prototype-chakracore-8.x.

The current plan is to provide N-API support in versions 8.X and 6.X
directly. For older versions, such as 4.X or pre N-API versions of 6.X,
we plan to create an external npm module to provide a migration path
that will allow modules targeting older Node.js versions to use the API,
albeit without getting the advantage of not having to recompile.

In addition, we also plan an external npm package with C++ sugar to
simplify the use of the API. The sugar will be in-line only and will
only use the exported N-API methods but is not part of the N-API
itself. The current version is in:
https://github.com/nodejs/node-api.

This PR is a result of work in the abi-stable-node repo:
https://github.com/nodejs/abi-stable-node/tree/doc,
with this PR being the cumulative work on the api-prototype-8.x
branch with the following contributors in alphabetical order:

Author: Arunesh Chandra <arunesh.chandra@microsoft.com>
Author: Gabriel Schulhof <gabriel.schulhof@intel.com>
Author: Hitesh Kanwathirtha <hiteshk@microsoft.com>
Author: Ian Halliday <ianhall@microsoft.com>
Author: Jason Ginchereau <jasongin@microsoft.com>
Author: Michael Dawson <michael_dawson@ca.ibm.com>
Author: Sampson Gao <sampsong@ca.ibm.com>
Author: Taylor Woll <taylor.woll@microsoft.com>
PR-URL: https://github.com/nodejs/node/pull/11975
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 Makefile                                      |   60 +-
 doc/api/cli.md                                |    8 +
 doc/node.1                                    |    5 +
 node.gyp                                      |    3 +
 src/node.cc                                   |   29 +-
 src/node_api.cc                               | 2529 +++++++++++++++++
 src/node_api.h                                |  479 ++++
 src/node_api_backport.h                       |   10 +
 src/node_api_types.h                          |   95 +
 test/addons-napi/.gitignore                   |    7 +
 test/addons-napi/1_hello_world/binding.c      |   22 +
 test/addons-napi/1_hello_world/binding.gyp    |    8 +
 test/addons-napi/1_hello_world/test.js        |    6 +
 .../2_function_arguments/binding.c            |   58 +
 .../2_function_arguments/binding.gyp          |    8 +
 test/addons-napi/2_function_arguments/test.js |    6 +
 test/addons-napi/3_callbacks/binding.c        |   51 +
 test/addons-napi/3_callbacks/binding.gyp      |    8 +
 test/addons-napi/3_callbacks/test.js          |   22 +
 test/addons-napi/4_object_factory/binding.c   |   31 +
 test/addons-napi/4_object_factory/binding.gyp |    8 +
 test/addons-napi/4_object_factory/test.js     |    8 +
 test/addons-napi/5_function_factory/binding.c |   36 +
 .../5_function_factory/binding.gyp            |    8 +
 test/addons-napi/5_function_factory/test.js   |    7 +
 test/addons-napi/6_object_wrap/binding.cc     |    7 +
 test/addons-napi/6_object_wrap/binding.gyp    |    8 +
 test/addons-napi/6_object_wrap/myobject.cc    |  201 ++
 test/addons-napi/6_object_wrap/myobject.h     |   26 +
 test/addons-napi/6_object_wrap/test.js        |   19 +
 test/addons-napi/7_factory_wrap/binding.cc    |   32 +
 test/addons-napi/7_factory_wrap/binding.gyp   |    8 +
 test/addons-napi/7_factory_wrap/myobject.cc   |  110 +
 test/addons-napi/7_factory_wrap/myobject.h    |   26 +
 test/addons-napi/7_factory_wrap/test.js       |   14 +
 test/addons-napi/8_passing_wrapped/binding.cc |   57 +
 .../addons-napi/8_passing_wrapped/binding.gyp |    8 +
 .../addons-napi/8_passing_wrapped/myobject.cc |   81 +
 test/addons-napi/8_passing_wrapped/myobject.h |   26 +
 test/addons-napi/8_passing_wrapped/test.js    |    9 +
 test/addons-napi/test_array/binding.gyp       |    8 +
 test/addons-napi/test_array/test.js           |   37 +
 test/addons-napi/test_array/test_array.c      |  137 +
 test/addons-napi/test_buffer/binding.gyp      |    8 +
 test/addons-napi/test_buffer/test.js          |   25 +
 test/addons-napi/test_buffer/test_buffer.c    |  160 ++
 test/addons-napi/test_constructor/binding.gyp |    8 +
 test/addons-napi/test_constructor/test.js     |   28 +
 .../test_constructor/test_constructor.c       |  104 +
 test/addons-napi/test_conversions/binding.gyp |    8 +
 test/addons-napi/test_conversions/test.js     |  140 +
 .../test_conversions/test_conversions.c       |  237 ++
 test/addons-napi/test_error/binding.gyp       |    8 +
 test/addons-napi/test_error/test.js           |   57 +
 test/addons-napi/test_error/test_error.cc     |   37 +
 test/addons-napi/test_exception/binding.gyp   |    8 +
 test/addons-napi/test_exception/test.js       |   53 +
 .../test_exception/test_exception.c           |   75 +
 test/addons-napi/test_function/binding.gyp    |    8 +
 test/addons-napi/test_function/test.js        |   28 +
 .../addons-napi/test_function/test_function.c |   55 +
 test/addons-napi/test_instanceof/binding.gyp  |    8 +
 test/addons-napi/test_instanceof/test.js      |   87 +
 .../test_instanceof/test_instanceof.c         |   39 +
 test/addons-napi/test_number/binding.gyp      |    8 +
 test/addons-napi/test_number/test.js          |   39 +
 test/addons-napi/test_number/test_number.c    |   55 +
 test/addons-napi/test_object/binding.gyp      |    8 +
 test/addons-napi/test_object/test.js          |   65 +
 test/addons-napi/test_object/test_object.c    |  246 ++
 test/addons-napi/test_properties/binding.gyp  |    8 +
 test/addons-napi/test_properties/test.js      |   27 +
 .../test_properties/test_properties.c         |   85 +
 test/addons-napi/test_string/binding.gyp      |    8 +
 test/addons-napi/test_string/test.js          |   26 +
 test/addons-napi/test_string/test_string.c    |  134 +
 test/addons-napi/test_symbol/binding.gyp      |    8 +
 test/addons-napi/test_symbol/test1.js         |   20 +
 test/addons-napi/test_symbol/test2.js         |   15 +
 test/addons-napi/test_symbol/test3.js         |   19 +
 test/addons-napi/test_symbol/test_symbol.c    |   94 +
 test/addons-napi/test_typedarray/binding.gyp  |    8 +
 test/addons-napi/test_typedarray/test.js      |   39 +
 .../test_typedarray/test_typedarray.c         |  144 +
 test/addons-napi/testcfg.py                   |    6 +
 test/testpy/__init__.py                       |    2 +-
 tools/install.py                              |    2 +
 tools/test.py                                 |    1 +
 vcbuild.bat                                   |   30 +-
 89 files changed, 6586 insertions(+), 18 deletions(-)
 create mode 100644 src/node_api.cc
 create mode 100644 src/node_api.h
 create mode 100644 src/node_api_backport.h
 create mode 100644 src/node_api_types.h
 create mode 100644 test/addons-napi/.gitignore
 create mode 100644 test/addons-napi/1_hello_world/binding.c
 create mode 100644 test/addons-napi/1_hello_world/binding.gyp
 create mode 100644 test/addons-napi/1_hello_world/test.js
 create mode 100644 test/addons-napi/2_function_arguments/binding.c
 create mode 100644 test/addons-napi/2_function_arguments/binding.gyp
 create mode 100644 test/addons-napi/2_function_arguments/test.js
 create mode 100644 test/addons-napi/3_callbacks/binding.c
 create mode 100644 test/addons-napi/3_callbacks/binding.gyp
 create mode 100644 test/addons-napi/3_callbacks/test.js
 create mode 100644 test/addons-napi/4_object_factory/binding.c
 create mode 100644 test/addons-napi/4_object_factory/binding.gyp
 create mode 100644 test/addons-napi/4_object_factory/test.js
 create mode 100644 test/addons-napi/5_function_factory/binding.c
 create mode 100644 test/addons-napi/5_function_factory/binding.gyp
 create mode 100644 test/addons-napi/5_function_factory/test.js
 create mode 100644 test/addons-napi/6_object_wrap/binding.cc
 create mode 100644 test/addons-napi/6_object_wrap/binding.gyp
 create mode 100644 test/addons-napi/6_object_wrap/myobject.cc
 create mode 100644 test/addons-napi/6_object_wrap/myobject.h
 create mode 100644 test/addons-napi/6_object_wrap/test.js
 create mode 100644 test/addons-napi/7_factory_wrap/binding.cc
 create mode 100644 test/addons-napi/7_factory_wrap/binding.gyp
 create mode 100644 test/addons-napi/7_factory_wrap/myobject.cc
 create mode 100644 test/addons-napi/7_factory_wrap/myobject.h
 create mode 100644 test/addons-napi/7_factory_wrap/test.js
 create mode 100644 test/addons-napi/8_passing_wrapped/binding.cc
 create mode 100644 test/addons-napi/8_passing_wrapped/binding.gyp
 create mode 100644 test/addons-napi/8_passing_wrapped/myobject.cc
 create mode 100644 test/addons-napi/8_passing_wrapped/myobject.h
 create mode 100644 test/addons-napi/8_passing_wrapped/test.js
 create mode 100644 test/addons-napi/test_array/binding.gyp
 create mode 100644 test/addons-napi/test_array/test.js
 create mode 100644 test/addons-napi/test_array/test_array.c
 create mode 100644 test/addons-napi/test_buffer/binding.gyp
 create mode 100644 test/addons-napi/test_buffer/test.js
 create mode 100644 test/addons-napi/test_buffer/test_buffer.c
 create mode 100644 test/addons-napi/test_constructor/binding.gyp
 create mode 100644 test/addons-napi/test_constructor/test.js
 create mode 100644 test/addons-napi/test_constructor/test_constructor.c
 create mode 100644 test/addons-napi/test_conversions/binding.gyp
 create mode 100644 test/addons-napi/test_conversions/test.js
 create mode 100644 test/addons-napi/test_conversions/test_conversions.c
 create mode 100644 test/addons-napi/test_error/binding.gyp
 create mode 100644 test/addons-napi/test_error/test.js
 create mode 100644 test/addons-napi/test_error/test_error.cc
 create mode 100644 test/addons-napi/test_exception/binding.gyp
 create mode 100644 test/addons-napi/test_exception/test.js
 create mode 100644 test/addons-napi/test_exception/test_exception.c
 create mode 100644 test/addons-napi/test_function/binding.gyp
 create mode 100644 test/addons-napi/test_function/test.js
 create mode 100644 test/addons-napi/test_function/test_function.c
 create mode 100644 test/addons-napi/test_instanceof/binding.gyp
 create mode 100644 test/addons-napi/test_instanceof/test.js
 create mode 100644 test/addons-napi/test_instanceof/test_instanceof.c
 create mode 100644 test/addons-napi/test_number/binding.gyp
 create mode 100644 test/addons-napi/test_number/test.js
 create mode 100644 test/addons-napi/test_number/test_number.c
 create mode 100644 test/addons-napi/test_object/binding.gyp
 create mode 100644 test/addons-napi/test_object/test.js
 create mode 100644 test/addons-napi/test_object/test_object.c
 create mode 100644 test/addons-napi/test_properties/binding.gyp
 create mode 100644 test/addons-napi/test_properties/test.js
 create mode 100644 test/addons-napi/test_properties/test_properties.c
 create mode 100644 test/addons-napi/test_string/binding.gyp
 create mode 100644 test/addons-napi/test_string/test.js
 create mode 100644 test/addons-napi/test_string/test_string.c
 create mode 100644 test/addons-napi/test_symbol/binding.gyp
 create mode 100644 test/addons-napi/test_symbol/test1.js
 create mode 100644 test/addons-napi/test_symbol/test2.js
 create mode 100644 test/addons-napi/test_symbol/test3.js
 create mode 100644 test/addons-napi/test_symbol/test_symbol.c
 create mode 100644 test/addons-napi/test_typedarray/binding.gyp
 create mode 100644 test/addons-napi/test_typedarray/test.js
 create mode 100644 test/addons-napi/test_typedarray/test_typedarray.c
 create mode 100644 test/addons-napi/testcfg.py

diff --git a/Makefile b/Makefile
index c947a2a4367d05..523a3d8c541ed8 100644
--- a/Makefile
+++ b/Makefile
@@ -120,9 +120,10 @@ v8:
 
 test: all
 	$(MAKE) build-addons
+	$(MAKE) build-addons-napi
 	$(MAKE) cctest
 	$(PYTHON) tools/test.py --mode=release -J \
-		doctool inspector known_issues message pseudo-tty parallel sequential addons
+		doctool inspector known_issues message pseudo-tty parallel sequential addons addons-napi
 	$(MAKE) lint
 
 test-parallel: all
@@ -189,6 +190,41 @@ test/addons/.buildstamp: config.gypi \
 # TODO(bnoordhuis) Force rebuild after gyp update.
 build-addons: $(NODE_EXE) test/addons/.buildstamp
 
+ADDONS_NAPI_BINDING_GYPS := \
+	$(filter-out test/addons-napi/??_*/binding.gyp, \
+		$(wildcard test/addons-napi/*/binding.gyp))
+
+ADDONS_NAPI_BINDING_SOURCES := \
+	$(filter-out test/addons-napi/??_*/*.cc, $(wildcard test/addons-napi/*/*.cc)) \
+	$(filter-out test/addons-napi/??_*/*.h, $(wildcard test/addons-napi/*/*.h))
+
+# Implicitly depends on $(NODE_EXE), see the build-addons-napi rule for rationale.
+test/addons-napi/.buildstamp: config.gypi \
+	deps/npm/node_modules/node-gyp/package.json \
+	$(ADDONS_NAPI_BINDING_GYPS) $(ADDONS_NAPI_BINDING_SOURCES) \
+	deps/uv/include/*.h deps/v8/include/*.h \
+	src/node.h src/node_buffer.h src/node_object_wrap.h src/node_version.h \
+	src/node_api.h src/node_api_types.h
+#	Cannot use $(wildcard test/addons-napi/*/) here, it's evaluated before
+#	embedded addons have been generated from the documentation.
+	@for dirname in test/addons-napi/*/; do \
+		printf "\nBuilding addon $$PWD/$$dirname\n" ; \
+		env MAKEFLAGS="-j1" $(NODE) deps/npm/node_modules/node-gyp/bin/node-gyp \
+		        --loglevel=$(LOGLEVEL) rebuild \
+			--python="$(PYTHON)" \
+			--directory="$$PWD/$$dirname" \
+			--nodedir="$$PWD" || exit 1 ; \
+	done
+	touch $@
+
+# .buildstamp and .docbuildstamp need $(NODE_EXE) but cannot depend on it
+# directly because it calls make recursively.  The parent make cannot know
+# if the subprocess touched anything so it pessimistically assumes that
+# .buildstamp and .docbuildstamp are out of date and need a rebuild.
+# Just goes to show that recursive make really is harmful...
+# TODO(bnoordhuis) Force rebuild after gyp or node-gyp update.
+build-addons-napi: $(NODE_EXE) test/addons-napi/.buildstamp
+
 clear-stalled:
 	# Clean up any leftover processes but don't error if found.
 	ps awwx | grep Release/node | grep -v grep | cat
@@ -200,7 +236,9 @@ clear-stalled:
 test-gc: all test/gc/node_modules/weak/build/Release/weakref.node
 	$(PYTHON) tools/test.py --mode=release gc
 
-test-build: | all build-addons
+test-build: | all build-addons build-addons-napi
+
+test-build-addons-napi: all build-addons-napi
 
 test-all: test-build test/gc/node_modules/weak/build/Release/weakref.node
 	$(PYTHON) tools/test.py --mode=debug,release
@@ -208,12 +246,12 @@ test-all: test-build test/gc/node_modules/weak/build/Release/weakref.node
 test-all-valgrind: test-build
 	$(PYTHON) tools/test.py --mode=debug,release --valgrind
 
-CI_NATIVE_SUITES := addons
+CI_NATIVE_SUITES := addons addons-napi
 CI_JS_SUITES := doctool inspector known_issues message parallel pseudo-tty sequential
 
 # Build and test addons without building anything else
 test-ci-native: LOGLEVEL := info
-test-ci-native: | test/addons/.buildstamp
+test-ci-native: | test/addons/.buildstamp test/addons-napi/.buildstamp
 	$(PYTHON) tools/test.py $(PARALLEL_ARGS) -p tap --logfile test.tap \
 		--mode=release --flaky-tests=$(FLAKY_TESTS) \
 		$(TEST_CI_ARGS) $(CI_NATIVE_SUITES)
@@ -231,11 +269,11 @@ test-ci-js: | clear-stalled
 	fi
 
 test-ci: LOGLEVEL := info
-test-ci: | clear-stalled build-addons
+test-ci: | clear-stalled build-addons build-addons-napi
 	out/Release/cctest --gtest_output=tap:cctest.tap
 	$(PYTHON) tools/test.py $(PARALLEL_ARGS) -p tap --logfile test.tap \
 		--mode=release --flaky-tests=$(FLAKY_TESTS) \
-		$(TEST_CI_ARGS) $(CI_JS_SUITES) $(CI_NATIVE_SUITES)
+		$(TEST_CI_ARGS) $(CI_JS_SUITES) addons-napi $(CI_NATIVE_SUITES)
 	# Clean up any leftover processes, error if found.
 	ps awwx | grep Release/node | grep -v grep | cat
 	@PS_OUT=`ps awwx | grep Release/node | grep -v grep | awk '{print $$1}'`; \
@@ -282,7 +320,10 @@ test-npm: $(NODE_EXE)
 test-npm-publish: $(NODE_EXE)
 	npm_package_config_publishtest=true $(NODE) deps/npm/test/run.js
 
-test-addons: test-build
+test-addons-napi: test-build-addons-napi
+	$(PYTHON) tools/test.py --mode=release addons-napi
+
+test-addons: test-build test-addons-napi
 	$(PYTHON) tools/test.py --mode=release addons
 
 test-addons-clean:
@@ -813,6 +854,8 @@ LINT_CPP_FILES = $(filter-out $(LINT_CPP_EXCLUDE), $(wildcard \
 	test/addons/*/*.h \
 	test/cctest/*.cc \
 	test/cctest/*.h \
+	test/addons-napi/*/*.cc \
+	test/addons-napi/*/*.h \
 	tools/icu/*.cc \
 	tools/icu/*.h \
 	))
@@ -857,5 +900,6 @@ endif
         bench-buffer bench-net bench-http bench-fs bench-tls cctest run-ci \
         test-v8 test-v8-intl test-v8-benchmarks test-v8-all v8 lint-ci \
         bench-ci lint-js-ci doc-only $(TARBALL)-headers test-ci test-ci-native \
-        test-ci-js build-ci test-hash-seed clear-stalled
+        test-ci-js build-ci test-hash-seed clear-stalled  test-addons-napi \
+        build-addons-napi
 
diff --git a/doc/api/cli.md b/doc/api/cli.md
index f1b33e883ae883..5bcb6f3b4d0107 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -119,6 +119,14 @@ added: v6.0.0
 
 Silence all process warnings (including deprecations).
 
+### `--napi-modules`
+<!-- YAML
+added: REPLACEME
+-->
+
+Enable loading native modules compiled with the ABI-stable Node.js API (N-API)
+(experimental).
+
 ### `--trace-warnings`
 <!-- YAML
 added: v6.0.0
diff --git a/doc/node.1 b/doc/node.1
index 1e1877376dc3aa..b36f176983787f 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -108,6 +108,11 @@ Throw errors for deprecations.
 .BR \-\-no\-warnings
 Silence all process warnings (including deprecations).
 
+.TP
+.BR \-\-napi\-modules
+Enable loading native modules compiled with the ABI-stable Node.js API (N-API)
+(experimental).
+
 .TP
 .BR \-\-trace\-warnings
 Print stack traces for process warnings (including deprecations).
diff --git a/node.gyp b/node.gyp
index 7dff6bf3f22c1e..e37aadc036ef59 100644
--- a/node.gyp
+++ b/node.gyp
@@ -241,6 +241,9 @@
         'src/handle_wrap.cc',
         'src/js_stream.cc',
         'src/node.cc',
+        'src/node_api.cc',
+        'src/node_api.h',
+        'src/node_api_types.h',
         'src/node_buffer.cc',
         'src/node_config.cc',
         'src/node_constants.cc',
diff --git a/src/node.cc b/src/node.cc
index be82939e00b708..46ca0cd9ec5020 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -167,6 +167,9 @@ static node_module* modlist_addon;
 static std::string icu_data_dir;  // NOLINT(runtime/string)
 #endif
 
+// N-API is in experimental state, disabled by default.
+bool load_napi_modules = false;
+
 // used by C++ modules as well
 bool no_deprecation = false;
 
@@ -2502,10 +2505,20 @@ void DLOpen(const FunctionCallbackInfo<Value>& args) {
   }
   if (mp->nm_version != NODE_MODULE_VERSION) {
     char errmsg[1024];
-    snprintf(errmsg,
-             sizeof(errmsg),
-             "Module version mismatch. Expected %d, got %d.",
-             NODE_MODULE_VERSION, mp->nm_version);
+    if (mp->nm_version == -1) {
+      snprintf(errmsg,
+               sizeof(errmsg),
+               "The module '%s'"
+               "\nwas compiled against the ABI-stable Node.js API (N-API)."
+               "\nThis feature is experimental and must be enabled on the "
+               "\ncommand-line by adding --napi-modules.",
+               *filename);
+    } else {
+      snprintf(errmsg,
+               sizeof(errmsg),
+               "Module version mismatch. Expected %d, got %d.",
+               NODE_MODULE_VERSION, mp->nm_version);
+    }
 
     // NOTE: `mp` is allocated inside of the shared library's memory, calling
     // `uv_dlclose` will deallocate it
@@ -3719,6 +3732,7 @@ static void PrintHelp() {
          "  --throw-deprecation   throw an exception anytime a deprecated "
          "function is used\n"
          "  --no-warnings         silence all process warnings\n"
+         "  --napi-modules        load N-API modules\n"
          "  --trace-warnings      show stack traces on process warnings\n"
          "  --redirect-warnings=path\n"
          "                        write warnings to path instead of stderr\n"
@@ -3964,6 +3978,8 @@ static void ParseArgs(int* argc,
       force_repl = true;
     } else if (strcmp(arg, "--no-deprecation") == 0) {
       no_deprecation = true;
+    } else if (strcmp(arg, "--napi-modules") == 0) {
+      load_napi_modules = true;
     } else if (strcmp(arg, "--no-warnings") == 0) {
       no_process_warnings = true;
     } else if (strcmp(arg, "--trace-warnings") == 0) {
@@ -4862,6 +4878,11 @@ static void StartNodeInstance(void* arg) {
     if (instance_data->use_debug_agent())
       EnableDebug(env);
 
+    if (load_napi_modules) {
+      ProcessEmitWarning(env, "N-API is an experimental feature "
+          "and could change at any time.");
+    }
+
     {
       SealHandleScope seal(isolate);
       bool more;
diff --git a/src/node_api.cc b/src/node_api.cc
new file mode 100644
index 00000000000000..8269941e6812cd
--- /dev/null
+++ b/src/node_api.cc
@@ -0,0 +1,2529 @@
+/******************************************************************************
+ * Experimental prototype for demonstrating VM agnostic and ABI stable API
+ * for native modules to use instead of using Nan and V8 APIs directly.
+ *
+ * The current status is "Experimental" and should not be used for
+ * production applications.  The API is still subject to change
+ * and as an experimental feature is NOT subject to semver.
+ *
+ ******************************************************************************/
+
+
+#include <node_buffer.h>
+#include <node_object_wrap.h>
+#include <string.h>
+#include <algorithm>
+#include <cmath>
+#include <vector>
+#include "node_api.h"
+#include "node_api_backport.h"
+
+namespace v8impl {
+
+//=== Conversion between V8 Isolate and napi_env ==========================
+
+napi_env JsEnvFromV8Isolate(v8::Isolate* isolate) {
+  return reinterpret_cast<napi_env>(isolate);
+}
+
+v8::Isolate* V8IsolateFromJsEnv(napi_env e) {
+  return reinterpret_cast<v8::Isolate*>(e);
+}
+
+class HandleScopeWrapper {
+ public:
+  explicit HandleScopeWrapper(v8::Isolate* isolate) : scope(isolate) {}
+
+ private:
+  v8::HandleScope scope;
+};
+
+// In node v0.10 version of v8, there is no EscapableHandleScope and the
+// node v0.10 port use HandleScope::Close(Local<T> v) to mimic the behavior
+// of a EscapableHandleScope::Escape(Local<T> v), but it is not the same
+// semantics. This is an example of where the api abstraction fail to work
+// across different versions.
+class EscapableHandleScopeWrapper {
+ public:
+  explicit EscapableHandleScopeWrapper(v8::Isolate* isolate) : scope(isolate) {}
+  template <typename T>
+  v8::Local<T> Escape(v8::Local<T> handle) {
+    return scope.Escape(handle);
+  }
+
+ private:
+  v8::EscapableHandleScope scope;
+};
+
+napi_handle_scope JsHandleScopeFromV8HandleScope(HandleScopeWrapper* s) {
+  return reinterpret_cast<napi_handle_scope>(s);
+}
+
+HandleScopeWrapper* V8HandleScopeFromJsHandleScope(napi_handle_scope s) {
+  return reinterpret_cast<HandleScopeWrapper*>(s);
+}
+
+napi_escapable_handle_scope JsEscapableHandleScopeFromV8EscapableHandleScope(
+    EscapableHandleScopeWrapper* s) {
+  return reinterpret_cast<napi_escapable_handle_scope>(s);
+}
+
+EscapableHandleScopeWrapper*
+V8EscapableHandleScopeFromJsEscapableHandleScope(
+    napi_escapable_handle_scope s) {
+  return reinterpret_cast<EscapableHandleScopeWrapper*>(s);
+}
+
+//=== Conversion between V8 Handles and napi_value ========================
+
+// This asserts v8::Local<> will always be implemented with a single
+// pointer field so that we can pass it around as a void*.
+static_assert(sizeof(v8::Local<v8::Value>) == sizeof(napi_value),
+  "Cannot convert between v8::Local<v8::Value> and napi_value");
+
+napi_value JsValueFromV8LocalValue(v8::Local<v8::Value> local) {
+  return reinterpret_cast<napi_value>(*local);
+}
+
+v8::Local<v8::Value> V8LocalValueFromJsValue(napi_value v) {
+  v8::Local<v8::Value> local;
+  memcpy(&local, &v, sizeof(v));
+  return local;
+}
+
+// Adapter for napi_finalize callbacks.
+class Finalizer {
+ protected:
+  Finalizer(v8::Isolate* isolate,
+             napi_finalize finalize_callback,
+             void* finalize_data,
+             void* finalize_hint)
+    : _isolate(isolate),
+      _finalize_callback(finalize_callback),
+      _finalize_data(finalize_data),
+      _finalize_hint(finalize_hint) {
+  }
+
+  ~Finalizer() {
+  }
+
+ public:
+  static Finalizer* New(v8::Isolate* isolate,
+                        napi_finalize finalize_callback = nullptr,
+                        void* finalize_data = nullptr,
+                        void* finalize_hint = nullptr) {
+    return new Finalizer(
+      isolate, finalize_callback, finalize_data, finalize_hint);
+  }
+
+  static void Delete(Finalizer* finalizer) {
+    delete finalizer;
+  }
+
+  // node::Buffer::FreeCallback
+  static void FinalizeBufferCallback(char* data, void* hint) {
+    Finalizer* finalizer = static_cast<Finalizer*>(hint);
+    if (finalizer->_finalize_callback != nullptr) {
+      finalizer->_finalize_callback(
+        v8impl::JsEnvFromV8Isolate(finalizer->_isolate),
+        data,
+        finalizer->_finalize_hint);
+    }
+
+    Delete(finalizer);
+  }
+
+ protected:
+  v8::Isolate* _isolate;
+  napi_finalize _finalize_callback;
+  void* _finalize_data;
+  void* _finalize_hint;
+};
+
+// Wrapper around v8::Persistent that implements reference counting.
+class Reference : private Finalizer {
+ private:
+  Reference(v8::Isolate* isolate,
+            v8::Local<v8::Value> value,
+            uint32_t initial_refcount,
+            bool delete_self,
+            napi_finalize finalize_callback,
+            void* finalize_data,
+            void* finalize_hint)
+       : Finalizer(isolate, finalize_callback, finalize_data, finalize_hint),
+        _persistent(isolate, value),
+        _refcount(initial_refcount),
+        _delete_self(delete_self) {
+    if (initial_refcount == 0) {
+      _persistent.SetWeak(
+          this, FinalizeCallback, v8::WeakCallbackType::kParameter);
+      _persistent.MarkIndependent();
+    }
+  }
+
+  ~Reference() {
+    // The V8 Persistent class currently does not reset in its destructor:
+    // see NonCopyablePersistentTraits::kResetInDestructor = false.
+    // (Comments there claim that might change in the future.)
+    // To avoid memory leaks, it is better to reset at this time, however
+    // care must be taken to avoid attempting this after the Isolate has
+    // shut down, for example via a static (atexit) destructor.
+    _persistent.Reset();
+  }
+
+ public:
+  static Reference* New(v8::Isolate* isolate,
+                        v8::Local<v8::Value> value,
+                        uint32_t initial_refcount,
+                        bool delete_self,
+                        napi_finalize finalize_callback = nullptr,
+                        void* finalize_data = nullptr,
+                        void* finalize_hint = nullptr) {
+    return new Reference(isolate,
+      value,
+      initial_refcount,
+      delete_self,
+      finalize_callback,
+      finalize_data,
+      finalize_hint);
+  }
+
+  static void Delete(Reference* reference) {
+    delete reference;
+  }
+
+  uint32_t Ref() {
+    if (++_refcount == 1) {
+      _persistent.ClearWeak();
+    }
+
+    return _refcount;
+  }
+
+  uint32_t Unref() {
+    if (_refcount == 0) {
+        return 0;
+    }
+    if (--_refcount == 0) {
+      _persistent.SetWeak(
+          this, FinalizeCallback, v8::WeakCallbackType::kParameter);
+      _persistent.MarkIndependent();
+    }
+
+    return _refcount;
+  }
+
+  uint32_t RefCount() {
+    return _refcount;
+  }
+
+  v8::Local<v8::Value> Get() {
+    if (_persistent.IsEmpty()) {
+      return v8::Local<v8::Value>();
+    } else {
+      return v8::Local<v8::Value>::New(_isolate, _persistent);
+    }
+  }
+
+ private:
+  static void FinalizeCallback(const v8::WeakCallbackInfo<Reference>& data) {
+    Reference* reference = data.GetParameter();
+    reference->_persistent.Reset();
+
+    // Check before calling the finalize callback, because the callback might
+    // delete it.
+    bool delete_self = reference->_delete_self;
+
+    if (reference->_finalize_callback != nullptr) {
+      reference->_finalize_callback(
+          v8impl::JsEnvFromV8Isolate(reference->_isolate),
+          reference->_finalize_data,
+          reference->_finalize_hint);
+    }
+
+    if (delete_self) {
+      Delete(reference);
+    }
+  }
+
+  v8::Persistent<v8::Value> _persistent;
+  uint32_t _refcount;
+  bool _delete_self;
+};
+
+class TryCatch : public v8::TryCatch {
+ public:
+  explicit TryCatch(v8::Isolate* isolate)
+      : v8::TryCatch(isolate), _isolate(isolate) {}
+
+  ~TryCatch() {
+    if (HasCaught()) {
+      _the_exception.Reset(_isolate, Exception());
+    }
+  }
+
+  static v8::Persistent<v8::Value>& LastException() { return _the_exception; }
+
+ private:
+  static v8::Persistent<v8::Value> _the_exception;
+  v8::Isolate* _isolate;
+};
+
+v8::Persistent<v8::Value> TryCatch::_the_exception;
+
+//=== Function napi_callback wrapper =================================
+
+static const int kDataIndex = 0;
+
+static const int kFunctionIndex = 1;
+static const int kFunctionFieldCount = 2;
+
+static const int kGetterIndex = 1;
+static const int kSetterIndex = 2;
+static const int kAccessorFieldCount = 3;
+
+// Base class extended by classes that wrap V8 function and property callback
+// info.
+class CallbackWrapper {
+ public:
+  CallbackWrapper(napi_value this_arg, size_t args_length, void* data)
+      : _this(this_arg), _args_length(args_length), _data(data) {}
+
+  virtual bool IsConstructCall() = 0;
+  virtual void Args(napi_value* buffer, size_t bufferlength) = 0;
+  virtual void SetReturnValue(napi_value value) = 0;
+
+  napi_value This() { return _this; }
+
+  size_t ArgsLength() { return _args_length; }
+
+  void* Data() { return _data; }
+
+ protected:
+  const napi_value _this;
+  const size_t _args_length;
+  void* _data;
+};
+
+template <typename Info, int kInternalFieldIndex>
+class CallbackWrapperBase : public CallbackWrapper {
+ public:
+  CallbackWrapperBase(const Info& cbinfo, const size_t args_length)
+      : CallbackWrapper(JsValueFromV8LocalValue(cbinfo.This()),
+                        args_length,
+                        nullptr),
+        _cbinfo(cbinfo),
+        _cbdata(v8::Local<v8::Object>::Cast(cbinfo.Data())) {
+    _data = v8::Local<v8::External>::Cast(_cbdata->GetInternalField(kDataIndex))
+                ->Value();
+  }
+
+  /*virtual*/
+  bool IsConstructCall() override { return false; }
+
+ protected:
+  void InvokeCallback() {
+    napi_callback_info cbinfo_wrapper = reinterpret_cast<napi_callback_info>(
+        static_cast<CallbackWrapper*>(this));
+    napi_callback cb = reinterpret_cast<napi_callback>(
+        v8::Local<v8::External>::Cast(
+            _cbdata->GetInternalField(kInternalFieldIndex))->Value());
+    v8::Isolate* isolate = _cbinfo.GetIsolate();
+    cb(v8impl::JsEnvFromV8Isolate(isolate), cbinfo_wrapper);
+
+    if (!TryCatch::LastException().IsEmpty()) {
+      isolate->ThrowException(
+          v8::Local<v8::Value>::New(isolate, TryCatch::LastException()));
+      TryCatch::LastException().Reset();
+    }
+  }
+
+  const Info& _cbinfo;
+  const v8::Local<v8::Object> _cbdata;
+};
+
+class FunctionCallbackWrapper
+    : public CallbackWrapperBase<v8::FunctionCallbackInfo<v8::Value>,
+                                 kFunctionIndex> {
+ public:
+  static void Invoke(const v8::FunctionCallbackInfo<v8::Value>& info) {
+    FunctionCallbackWrapper cbwrapper(info);
+    cbwrapper.InvokeCallback();
+  }
+
+  explicit FunctionCallbackWrapper(
+      const v8::FunctionCallbackInfo<v8::Value>& cbinfo)
+      : CallbackWrapperBase(cbinfo, cbinfo.Length()) {}
+
+  /*virtual*/
+  bool IsConstructCall() override { return _cbinfo.IsConstructCall(); }
+
+  /*virtual*/
+  void Args(napi_value* buffer, size_t buffer_length) override {
+    size_t i = 0;
+    size_t min = std::min(buffer_length, _args_length);
+
+    for (; i < min; i += 1) {
+      buffer[i] = v8impl::JsValueFromV8LocalValue(_cbinfo[i]);
+    }
+
+    if (i < buffer_length) {
+      napi_value undefined =
+          v8impl::JsValueFromV8LocalValue(v8::Undefined(_cbinfo.GetIsolate()));
+      for (; i < buffer_length; i += 1) {
+        buffer[i] = undefined;
+      }
+    }
+  }
+
+  /*virtual*/
+  void SetReturnValue(napi_value value) override {
+    v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+    _cbinfo.GetReturnValue().Set(val);
+  }
+};
+
+class GetterCallbackWrapper
+    : public CallbackWrapperBase<v8::PropertyCallbackInfo<v8::Value>,
+                                 kGetterIndex> {
+ public:
+  static void Invoke(v8::Local<v8::Name> property,
+                     const v8::PropertyCallbackInfo<v8::Value>& info) {
+    GetterCallbackWrapper cbwrapper(info);
+    cbwrapper.InvokeCallback();
+  }
+
+  explicit GetterCallbackWrapper(
+      const v8::PropertyCallbackInfo<v8::Value>& cbinfo)
+      : CallbackWrapperBase(cbinfo, 0) {}
+
+  /*virtual*/
+  void Args(napi_value* buffer, size_t buffer_length) override {
+    if (buffer_length > 0) {
+      napi_value undefined =
+          v8impl::JsValueFromV8LocalValue(v8::Undefined(_cbinfo.GetIsolate()));
+      for (size_t i = 0; i < buffer_length; i += 1) {
+        buffer[i] = undefined;
+      }
+    }
+  }
+
+  /*virtual*/
+  void SetReturnValue(napi_value value) override {
+    v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+    _cbinfo.GetReturnValue().Set(val);
+  }
+};
+
+class SetterCallbackWrapper
+    : public CallbackWrapperBase<v8::PropertyCallbackInfo<void>, kSetterIndex> {
+ public:
+  static void Invoke(v8::Local<v8::Name> property,
+                     v8::Local<v8::Value> value,
+                     const v8::PropertyCallbackInfo<void>& info) {
+    SetterCallbackWrapper cbwrapper(info, value);
+    cbwrapper.InvokeCallback();
+  }
+
+  SetterCallbackWrapper(const v8::PropertyCallbackInfo<void>& cbinfo,
+                        const v8::Local<v8::Value>& value)
+      : CallbackWrapperBase(cbinfo, 1), _value(value) {}
+
+  /*virtual*/
+  void Args(napi_value* buffer, size_t buffer_length) override {
+    if (buffer_length > 0) {
+      buffer[0] = v8impl::JsValueFromV8LocalValue(_value);
+
+      if (buffer_length > 1) {
+        napi_value undefined = v8impl::JsValueFromV8LocalValue(
+            v8::Undefined(_cbinfo.GetIsolate()));
+        for (size_t i = 1; i < buffer_length; i += 1) {
+          buffer[i] = undefined;
+        }
+      }
+    }
+  }
+
+  /*virtual*/
+  void SetReturnValue(napi_value value) override {
+    node::FatalError("napi_set_return_value",
+      "Cannot return a value from a setter callback.");
+  }
+
+ private:
+  const v8::Local<v8::Value>& _value;
+};
+
+// Creates an object to be made available to the static function callback
+// wrapper, used to retrieve the native callback function and data pointer.
+v8::Local<v8::Object> CreateFunctionCallbackData(napi_env env,
+                                                 napi_callback cb,
+                                                 void* data) {
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+  v8::Local<v8::ObjectTemplate> otpl = v8::ObjectTemplate::New(isolate);
+  otpl->SetInternalFieldCount(v8impl::kFunctionFieldCount);
+  v8::Local<v8::Object> cbdata = otpl->NewInstance(context).ToLocalChecked();
+
+  cbdata->SetInternalField(
+      v8impl::kFunctionIndex,
+      v8::External::New(isolate, reinterpret_cast<void*>(cb)));
+  cbdata->SetInternalField(
+      v8impl::kDataIndex,
+      v8::External::New(isolate, data));
+  return cbdata;
+}
+
+// Creates an object to be made available to the static getter/setter
+// callback wrapper, used to retrieve the native getter/setter callback
+// function and data pointer.
+v8::Local<v8::Object> CreateAccessorCallbackData(napi_env env,
+                                                 napi_callback getter,
+                                                 napi_callback setter,
+                                                 void* data) {
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+  v8::Local<v8::ObjectTemplate> otpl = v8::ObjectTemplate::New(isolate);
+  otpl->SetInternalFieldCount(v8impl::kAccessorFieldCount);
+  v8::Local<v8::Object> cbdata = otpl->NewInstance(context).ToLocalChecked();
+
+  if (getter != nullptr) {
+    cbdata->SetInternalField(
+        v8impl::kGetterIndex,
+        v8::External::New(isolate, reinterpret_cast<void*>(getter)));
+  }
+
+  if (setter != nullptr) {
+    cbdata->SetInternalField(
+        v8impl::kSetterIndex,
+        v8::External::New(isolate, reinterpret_cast<void*>(setter)));
+  }
+
+  cbdata->SetInternalField(
+      v8impl::kDataIndex,
+      v8::External::New(isolate, data));
+  return cbdata;
+}
+
+}  // end of namespace v8impl
+
+// Intercepts the Node-V8 module registration callback. Converts parameters
+// to NAPI equivalents and then calls the registration callback specified
+// by the NAPI module.
+void napi_module_register_cb(v8::Local<v8::Object> exports,
+                             v8::Local<v8::Value> module,
+                             v8::Local<v8::Context> context,
+                             void* priv) {
+  napi_module* mod = static_cast<napi_module*>(priv);
+  mod->nm_register_func(
+    v8impl::JsEnvFromV8Isolate(context->GetIsolate()),
+    v8impl::JsValueFromV8LocalValue(exports),
+    v8impl::JsValueFromV8LocalValue(module),
+    mod->nm_priv);
+}
+
+#ifndef EXTERNAL_NAPI
+namespace node {
+  // Indicates whether NAPI was enabled/disabled via the node command-line.
+  extern bool load_napi_modules;
+}
+#endif  // EXTERNAL_NAPI
+
+// Registers a NAPI module.
+void napi_module_register(napi_module* mod) {
+  // NAPI modules always work with the current node version.
+  int module_version = NODE_MODULE_VERSION;
+
+#ifndef EXTERNAL_NAPI
+  if (!node::load_napi_modules) {
+    // NAPI is disabled, so set the module version to -1 to cause the module
+    // to be unloaded.
+    module_version = -1;
+  }
+#endif  // EXTERNAL_NAPI
+
+  node::node_module* nm = new node::node_module {
+    module_version,
+    mod->nm_flags,
+    nullptr,
+    mod->nm_filename,
+    nullptr,
+    napi_module_register_cb,
+    mod->nm_modname,
+    mod,  // priv
+    nullptr,
+  };
+  node::node_module_register(nm);
+}
+
+#define RETURN_STATUS_IF_FALSE(condition, status)                       \
+  do {                                                                  \
+    if (!(condition)) {                                                 \
+      return napi_set_last_error((status));                             \
+    }                                                                   \
+  } while (0)
+
+#define CHECK_ARG(arg) RETURN_STATUS_IF_FALSE((arg), napi_invalid_arg)
+
+#define CHECK_MAYBE_EMPTY(maybe, status) \
+  RETURN_STATUS_IF_FALSE(!((maybe).IsEmpty()), (status))
+
+#define CHECK_MAYBE_NOTHING(maybe, status) \
+  RETURN_STATUS_IF_FALSE(!((maybe).IsNothing()), (status))
+
+// NAPI_PREAMBLE is not wrapped in do..while: try_catch must have function scope
+#define NAPI_PREAMBLE(env)                                            \
+  CHECK_ARG(env);                                                     \
+  RETURN_STATUS_IF_FALSE(v8impl::TryCatch::LastException().IsEmpty(), \
+                         napi_pending_exception);                     \
+  napi_clear_last_error();                                            \
+  v8impl::TryCatch try_catch(v8impl::V8IsolateFromJsEnv((env)))
+
+#define CHECK_TO_TYPE(type, context, result, src, status)                     \
+  do {                                                                        \
+    auto maybe = v8impl::V8LocalValueFromJsValue((src))->To##type((context)); \
+    CHECK_MAYBE_EMPTY(maybe, (status));                                       \
+    result = maybe.ToLocalChecked();                                          \
+  } while (0)
+
+#define CHECK_TO_OBJECT(context, result, src) \
+  CHECK_TO_TYPE(Object, context, result, src, napi_object_expected)
+
+#define CHECK_TO_STRING(context, result, src) \
+  CHECK_TO_TYPE(String, context, result, src, napi_string_expected)
+
+#define CHECK_TO_NUMBER(context, result, src) \
+  CHECK_TO_TYPE(Number, context, result, src, napi_number_expected)
+
+#define CHECK_TO_BOOL(context, result, src) \
+  CHECK_TO_TYPE(Boolean, context, result, src, napi_boolean_expected)
+
+#define CHECK_NEW_FROM_UTF8_LEN(isolate, result, str, len)          \
+  do {                                                              \
+    auto str_maybe = v8::String::NewFromUtf8(                       \
+        (isolate), (str), v8::NewStringType::kInternalized, (len)); \
+    CHECK_MAYBE_EMPTY(str_maybe, napi_generic_failure);             \
+    result = str_maybe.ToLocalChecked();                            \
+  } while (0)
+
+#define CHECK_NEW_FROM_UTF8(isolate, result, str) \
+  CHECK_NEW_FROM_UTF8_LEN((isolate), (result), (str), -1)
+
+#define GET_RETURN_STATUS()        \
+  (!try_catch.HasCaught() ? napi_ok \
+                         : napi_set_last_error(napi_pending_exception))
+
+// Static last error returned from napi_get_last_error_info
+napi_extended_error_info static_last_error = { nullptr, nullptr, 0, napi_ok };
+
+// Warning: Keep in-sync with napi_status enum
+const char* error_messages[] = {nullptr,
+                                "Invalid pointer passed as argument",
+                                "An object was expected",
+                                "A string was expected",
+                                "A function was expected",
+                                "A number was expected",
+                                "A boolean was expected",
+                                "An array was expected",
+                                "Unknown failure",
+                                "An exception is pending"};
+
+void napi_clear_last_error() {
+  static_last_error.error_code = napi_ok;
+
+  // TODO(boingoing): Should this be a callback?
+  static_last_error.engine_error_code = 0;
+  static_last_error.engine_reserved = nullptr;
+}
+
+napi_status napi_set_last_error(napi_status error_code,
+                                uint32_t engine_error_code = 0,
+                                void* engine_reserved = nullptr) {
+  static_last_error.error_code = error_code;
+  static_last_error.engine_error_code = engine_error_code;
+  static_last_error.engine_reserved = engine_reserved;
+
+  return error_code;
+}
+
+napi_status napi_get_last_error_info(napi_env env,
+                                     const napi_extended_error_info** result) {
+  CHECK_ARG(env);
+
+  static_assert(node::arraysize(error_messages) == napi_status_last,
+      "Count of error messages must match count of error values");
+  assert(static_last_error.error_code < napi_status_last);
+
+  // Wait until someone requests the last error information to fetch the error
+  // message string
+  static_last_error.error_message =
+      error_messages[static_last_error.error_code];
+
+  *result = &static_last_error;
+  return napi_ok;
+}
+
+napi_status napi_create_function(napi_env env,
+                                 const char* utf8name,
+                                 napi_callback cb,
+                                 void* callback_data,
+                                 napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Function> return_value;
+  v8::EscapableHandleScope scope(isolate);
+  v8::Local<v8::Object> cbdata =
+      v8impl::CreateFunctionCallbackData(env, cb, callback_data);
+
+  RETURN_STATUS_IF_FALSE(!cbdata.IsEmpty(), napi_generic_failure);
+
+  v8::Local<v8::FunctionTemplate> tpl = v8::FunctionTemplate::New(
+      isolate, v8impl::FunctionCallbackWrapper::Invoke, cbdata);
+
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::MaybeLocal<v8::Function> maybe_function = tpl->GetFunction(context);
+  CHECK_MAYBE_EMPTY(maybe_function, napi_generic_failure);
+
+  return_value = scope.Escape(maybe_function.ToLocalChecked());
+
+  if (utf8name != nullptr) {
+    v8::Local<v8::String> name_string;
+    CHECK_NEW_FROM_UTF8(isolate, name_string, utf8name);
+    return_value->SetName(name_string);
+  }
+
+  *result = v8impl::JsValueFromV8LocalValue(return_value);
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_define_class(napi_env env,
+                              const char* utf8name,
+                              napi_callback constructor,
+                              void* callback_data,
+                              size_t property_count,
+                              const napi_property_descriptor* properties,
+                              napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+
+  v8::EscapableHandleScope scope(isolate);
+  v8::Local<v8::Object> cbdata =
+      v8impl::CreateFunctionCallbackData(env, constructor, callback_data);
+
+  RETURN_STATUS_IF_FALSE(!cbdata.IsEmpty(), napi_generic_failure);
+
+  v8::Local<v8::FunctionTemplate> tpl = v8::FunctionTemplate::New(
+      isolate, v8impl::FunctionCallbackWrapper::Invoke, cbdata);
+
+  // we need an internal field to stash the wrapped object
+  tpl->InstanceTemplate()->SetInternalFieldCount(1);
+
+  v8::Local<v8::String> name_string;
+  CHECK_NEW_FROM_UTF8(isolate, name_string, utf8name);
+  tpl->SetClassName(name_string);
+
+  size_t static_property_count = 0;
+  for (size_t i = 0; i < property_count; i++) {
+    const napi_property_descriptor* p = properties + i;
+
+    if ((p->attributes & napi_static_property) != 0) {
+      // Static properties are handled separately below.
+      static_property_count++;
+      continue;
+    }
+
+    v8::Local<v8::String> property_name;
+    CHECK_NEW_FROM_UTF8(isolate, property_name, p->utf8name);
+
+    v8::PropertyAttribute attributes =
+        static_cast<v8::PropertyAttribute>(p->attributes);
+
+    // This code is similar to that in napi_define_property(); the
+    // difference is it applies to a template instead of an object.
+    if (p->method) {
+      v8::Local<v8::Object> cbdata =
+          v8impl::CreateFunctionCallbackData(env, p->method, p->data);
+
+      RETURN_STATUS_IF_FALSE(!cbdata.IsEmpty(), napi_generic_failure);
+
+      v8::Local<v8::FunctionTemplate> t =
+          v8::FunctionTemplate::New(isolate,
+                                    v8impl::FunctionCallbackWrapper::Invoke,
+                                    cbdata,
+                                    v8::Signature::New(isolate, tpl));
+      t->SetClassName(property_name);
+
+      tpl->PrototypeTemplate()->Set(property_name, t, attributes);
+    } else if (p->getter || p->setter) {
+      v8::Local<v8::Object> cbdata = v8impl::CreateAccessorCallbackData(
+        env, p->getter, p->setter, p->data);
+
+      tpl->PrototypeTemplate()->SetAccessor(
+        property_name,
+        p->getter ? v8impl::GetterCallbackWrapper::Invoke : nullptr,
+        p->setter ? v8impl::SetterCallbackWrapper::Invoke : nullptr,
+        cbdata,
+        v8::AccessControl::DEFAULT,
+        attributes);
+    } else {
+      v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(p->value);
+      tpl->PrototypeTemplate()->Set(property_name, value, attributes);
+    }
+  }
+
+  *result = v8impl::JsValueFromV8LocalValue(scope.Escape(tpl->GetFunction()));
+
+  if (static_property_count > 0) {
+    std::vector<napi_property_descriptor> static_descriptors;
+    static_descriptors.reserve(static_property_count);
+
+    for (size_t i = 0; i < property_count; i++) {
+      const napi_property_descriptor* p = properties + i;
+      if ((p->attributes & napi_static_property) != 0) {
+        static_descriptors.push_back(*p);
+      }
+    }
+
+    napi_status status =
+        napi_define_properties(env,
+                               *result,
+                               static_descriptors.size(),
+                               static_descriptors.data());
+    if (status != napi_ok) return status;
+  }
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_set_return_value(napi_env env,
+                                  napi_callback_info cbinfo,
+                                  napi_value value) {
+  NAPI_PREAMBLE(env);
+
+  v8impl::CallbackWrapper* info =
+      reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
+
+  info->SetReturnValue(value);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_get_property_names(napi_env env,
+                                    napi_value object,
+                                    napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Object> obj;
+  CHECK_TO_OBJECT(context, obj, object);
+
+  auto maybe_propertynames = obj->GetPropertyNames(context);
+
+  CHECK_MAYBE_EMPTY(maybe_propertynames, napi_generic_failure);
+
+  *result = v8impl::JsValueFromV8LocalValue(
+      maybe_propertynames.ToLocalChecked());
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_set_property(napi_env env,
+                              napi_value object,
+                              napi_value key,
+                              napi_value value) {
+  NAPI_PREAMBLE(env);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Object> obj;
+
+  CHECK_TO_OBJECT(context, obj, object);
+
+  v8::Local<v8::Value> k = v8impl::V8LocalValueFromJsValue(key);
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+
+  v8::Maybe<bool> set_maybe = obj->Set(context, k, val);
+
+  RETURN_STATUS_IF_FALSE(set_maybe.FromMaybe(false), napi_generic_failure);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_has_property(napi_env env,
+                              napi_value object,
+                              napi_value key,
+                              bool* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Object> obj;
+
+  CHECK_TO_OBJECT(context, obj, object);
+
+  v8::Local<v8::Value> k = v8impl::V8LocalValueFromJsValue(key);
+  v8::Maybe<bool> has_maybe = obj->Has(context, k);
+
+  CHECK_MAYBE_NOTHING(has_maybe, napi_generic_failure);
+
+  *result = has_maybe.FromMaybe(false);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_get_property(napi_env env,
+                              napi_value object,
+                              napi_value key,
+                              napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Value> k = v8impl::V8LocalValueFromJsValue(key);
+  v8::Local<v8::Object> obj;
+
+  CHECK_TO_OBJECT(context, obj, object);
+
+  auto get_maybe = obj->Get(context, k);
+
+  CHECK_MAYBE_EMPTY(get_maybe, napi_generic_failure);
+
+  v8::Local<v8::Value> val = get_maybe.ToLocalChecked();
+  *result = v8impl::JsValueFromV8LocalValue(val);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_set_named_property(napi_env env,
+                                    napi_value object,
+                                    const char* utf8name,
+                                    napi_value value) {
+  NAPI_PREAMBLE(env);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Object> obj;
+
+  CHECK_TO_OBJECT(context, obj, object);
+
+  v8::Local<v8::Name> key;
+  CHECK_NEW_FROM_UTF8(isolate, key, utf8name);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+
+  v8::Maybe<bool> set_maybe = obj->Set(context, key, val);
+
+  RETURN_STATUS_IF_FALSE(set_maybe.FromMaybe(false), napi_generic_failure);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_has_named_property(napi_env env,
+                                    napi_value object,
+                                    const char* utf8name,
+                                    bool* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Object> obj;
+
+  CHECK_TO_OBJECT(context, obj, object);
+
+  v8::Local<v8::Name> key;
+  CHECK_NEW_FROM_UTF8(isolate, key, utf8name);
+
+  v8::Maybe<bool> has_maybe = obj->Has(context, key);
+
+  CHECK_MAYBE_NOTHING(has_maybe, napi_generic_failure);
+
+  *result = has_maybe.FromMaybe(false);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_get_named_property(napi_env env,
+                                    napi_value object,
+                                    const char* utf8name,
+                                    napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+  v8::Local<v8::Name> key;
+  CHECK_NEW_FROM_UTF8(isolate, key, utf8name);
+
+  v8::Local<v8::Object> obj;
+
+  CHECK_TO_OBJECT(context, obj, object);
+
+  auto get_maybe = obj->Get(context, key);
+
+  CHECK_MAYBE_EMPTY(get_maybe, napi_generic_failure);
+
+  v8::Local<v8::Value> val = get_maybe.ToLocalChecked();
+  *result = v8impl::JsValueFromV8LocalValue(val);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_set_element(napi_env env,
+                             napi_value object,
+                             uint32_t index,
+                             napi_value value) {
+  NAPI_PREAMBLE(env);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Object> obj;
+
+  CHECK_TO_OBJECT(context, obj, object);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+  auto set_maybe = obj->Set(context, index, val);
+
+  RETURN_STATUS_IF_FALSE(set_maybe.FromMaybe(false), napi_generic_failure);
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_has_element(napi_env env,
+                             napi_value object,
+                             uint32_t index,
+                             bool* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Object> obj;
+
+  CHECK_TO_OBJECT(context, obj, object);
+
+  v8::Maybe<bool> has_maybe = obj->Has(context, index);
+
+  CHECK_MAYBE_NOTHING(has_maybe, napi_generic_failure);
+
+  *result = has_maybe.FromMaybe(false);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_get_element(napi_env env,
+                             napi_value object,
+                             uint32_t index,
+                             napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Object> obj;
+
+  CHECK_TO_OBJECT(context, obj, object);
+
+  auto get_maybe = obj->Get(context, index);
+
+  CHECK_MAYBE_EMPTY(get_maybe, napi_generic_failure);
+
+  *result = v8impl::JsValueFromV8LocalValue(get_maybe.ToLocalChecked());
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_define_properties(napi_env env,
+                                   napi_value object,
+                                   size_t property_count,
+                                   const napi_property_descriptor* properties) {
+  NAPI_PREAMBLE(env);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Object> obj =
+      v8impl::V8LocalValueFromJsValue(object).As<v8::Object>();
+
+  for (size_t i = 0; i < property_count; i++) {
+    const napi_property_descriptor* p = &properties[i];
+
+    v8::Local<v8::Name> name;
+    CHECK_NEW_FROM_UTF8(isolate, name, p->utf8name);
+
+    v8::PropertyAttribute attributes = static_cast<v8::PropertyAttribute>(
+        p->attributes & ~napi_static_property);
+
+    if (p->method) {
+      v8::Local<v8::Object> cbdata =
+          v8impl::CreateFunctionCallbackData(env, p->method, p->data);
+
+      RETURN_STATUS_IF_FALSE(!cbdata.IsEmpty(), napi_generic_failure);
+
+      v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(
+          isolate, v8impl::FunctionCallbackWrapper::Invoke, cbdata);
+
+      auto define_maybe =
+          obj->DefineOwnProperty(context, name, t->GetFunction(), attributes);
+
+      if (!define_maybe.FromMaybe(false)) {
+        return napi_set_last_error(napi_generic_failure);
+      }
+    } else if (p->getter || p->setter) {
+      v8::Local<v8::Object> cbdata = v8impl::CreateAccessorCallbackData(
+        env,
+        p->getter,
+        p->setter,
+        p->data);
+
+      auto set_maybe = obj->SetAccessor(
+          context,
+          name,
+          p->getter ? v8impl::GetterCallbackWrapper::Invoke : nullptr,
+          p->setter ? v8impl::SetterCallbackWrapper::Invoke : nullptr,
+          cbdata,
+          v8::AccessControl::DEFAULT,
+          attributes);
+
+      if (!set_maybe.FromMaybe(false)) {
+        return napi_set_last_error(napi_invalid_arg);
+      }
+    } else {
+      v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(p->value);
+
+      auto define_maybe =
+          obj->DefineOwnProperty(context, name, value, attributes);
+
+      if (!define_maybe.FromMaybe(false)) {
+        return napi_set_last_error(napi_invalid_arg);
+      }
+    }
+  }
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_is_array(napi_env env, napi_value value, bool* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+
+  *result = val->IsArray();
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_get_array_length(napi_env env,
+                                  napi_value value,
+                                  uint32_t* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+  RETURN_STATUS_IF_FALSE(val->IsArray(), napi_array_expected);
+
+  v8::Local<v8::Array> arr = val.As<v8::Array>();
+  *result = arr->Length();
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_strict_equals(napi_env env,
+                               napi_value lhs,
+                               napi_value rhs,
+                               bool* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> a = v8impl::V8LocalValueFromJsValue(lhs);
+  v8::Local<v8::Value> b = v8impl::V8LocalValueFromJsValue(rhs);
+
+  *result = a->StrictEquals(b);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_get_prototype(napi_env env,
+                               napi_value object,
+                               napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+  v8::Local<v8::Object> obj;
+  CHECK_TO_OBJECT(context, obj, object);
+
+  v8::Local<v8::Value> val = obj->GetPrototype();
+  *result = v8impl::JsValueFromV8LocalValue(val);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_create_object(napi_env env, napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  *result = v8impl::JsValueFromV8LocalValue(
+      v8::Object::New(v8impl::V8IsolateFromJsEnv(env)));
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_create_array(napi_env env, napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  *result = v8impl::JsValueFromV8LocalValue(
+      v8::Array::New(v8impl::V8IsolateFromJsEnv(env)));
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_create_array_with_length(napi_env env,
+                                          size_t length,
+                                          napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  *result = v8impl::JsValueFromV8LocalValue(
+      v8::Array::New(v8impl::V8IsolateFromJsEnv(env), length));
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_create_string_utf8(napi_env env,
+                                    const char* str,
+                                    size_t length,
+                                    napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  auto isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::String> s;
+  CHECK_NEW_FROM_UTF8_LEN(isolate, s, str, length);
+
+  *result = v8impl::JsValueFromV8LocalValue(s);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_create_string_utf16(napi_env env,
+                                     const char16_t* str,
+                                     size_t length,
+                                     napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  auto isolate = v8impl::V8IsolateFromJsEnv(env);
+  auto str_maybe =
+      v8::String::NewFromTwoByte(isolate,
+                                 reinterpret_cast<const uint16_t*>(str),
+                                 v8::NewStringType::kInternalized,
+                                 length);
+  CHECK_MAYBE_EMPTY(str_maybe, napi_generic_failure);
+
+  *result = v8impl::JsValueFromV8LocalValue(str_maybe.ToLocalChecked());
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_create_number(napi_env env,
+                               double value,
+                               napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  *result = v8impl::JsValueFromV8LocalValue(
+      v8::Number::New(v8impl::V8IsolateFromJsEnv(env), value));
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_get_boolean(napi_env env, bool value, napi_value* result) {
+  CHECK_ARG(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+
+  if (value) {
+    *result = v8impl::JsValueFromV8LocalValue(v8::True(isolate));
+  } else {
+    *result = v8impl::JsValueFromV8LocalValue(v8::False(isolate));
+  }
+
+  return napi_ok;
+}
+
+napi_status napi_create_symbol(napi_env env,
+                               napi_value description,
+                               napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+
+  if (description == nullptr) {
+    *result = v8impl::JsValueFromV8LocalValue(v8::Symbol::New(isolate));
+  } else {
+    v8::Local<v8::Value> desc = v8impl::V8LocalValueFromJsValue(description);
+    RETURN_STATUS_IF_FALSE(desc->IsString(), napi_string_expected);
+
+    *result = v8impl::JsValueFromV8LocalValue(
+      v8::Symbol::New(isolate, desc.As<v8::String>()));
+  }
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_create_error(napi_env env,
+                              napi_value msg,
+                              napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> message_value = v8impl::V8LocalValueFromJsValue(msg);
+  RETURN_STATUS_IF_FALSE(message_value->IsString(), napi_string_expected);
+
+  *result = v8impl::JsValueFromV8LocalValue(v8::Exception::Error(
+      message_value.As<v8::String>()));
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_create_type_error(napi_env env,
+                                   napi_value msg,
+                                   napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> message_value = v8impl::V8LocalValueFromJsValue(msg);
+  RETURN_STATUS_IF_FALSE(message_value->IsString(), napi_string_expected);
+
+  *result = v8impl::JsValueFromV8LocalValue(v8::Exception::TypeError(
+      message_value.As<v8::String>()));
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_create_range_error(napi_env env,
+                                    napi_value msg,
+                                    napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> message_value = v8impl::V8LocalValueFromJsValue(msg);
+  RETURN_STATUS_IF_FALSE(message_value->IsString(), napi_string_expected);
+
+  *result = v8impl::JsValueFromV8LocalValue(v8::Exception::RangeError(
+      message_value.As<v8::String>()));
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_typeof(napi_env env,
+                        napi_value value,
+                        napi_valuetype* result) {
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> v = v8impl::V8LocalValueFromJsValue(value);
+
+  if (v->IsNumber()) {
+    *result = napi_number;
+  } else if (v->IsString()) {
+    *result = napi_string;
+  } else if (v->IsFunction()) {
+    // This test has to come before IsObject because IsFunction
+    // implies IsObject
+    *result = napi_function;
+  } else if (v->IsObject()) {
+    *result = napi_object;
+  } else if (v->IsBoolean()) {
+    *result = napi_boolean;
+  } else if (v->IsUndefined()) {
+    *result = napi_undefined;
+  } else if (v->IsSymbol()) {
+    *result = napi_symbol;
+  } else if (v->IsNull()) {
+    *result = napi_null;
+  } else if (v->IsExternal()) {
+    *result = napi_external;
+  } else {
+    // Should not get here unless V8 has added some new kind of value.
+    return napi_set_last_error(napi_invalid_arg);
+  }
+
+  return napi_ok;
+}
+
+napi_status napi_get_undefined(napi_env env, napi_value* result) {
+  CHECK_ARG(env);
+  CHECK_ARG(result);
+
+  *result = v8impl::JsValueFromV8LocalValue(
+      v8::Undefined(v8impl::V8IsolateFromJsEnv(env)));
+
+  return napi_ok;
+}
+
+napi_status napi_get_null(napi_env env, napi_value* result) {
+  CHECK_ARG(env);
+  CHECK_ARG(result);
+
+  *result = v8impl::JsValueFromV8LocalValue(
+        v8::Null(v8impl::V8IsolateFromJsEnv(env)));
+
+  return napi_ok;
+}
+
+// Gets all callback info in a single call. (Ugly, but faster.)
+napi_status napi_get_cb_info(
+    napi_env env,               // [in] NAPI environment handle
+    napi_callback_info cbinfo,  // [in] Opaque callback-info handle
+    size_t* argc,      // [in-out] Specifies the size of the provided argv array
+                       // and receives the actual count of args.
+    napi_value* argv,  // [out] Array of values
+    napi_value* this_arg,  // [out] Receives the JS 'this' arg for the call
+    void** data) {         // [out] Receives the data pointer for the callback.
+  CHECK_ARG(argc);
+  CHECK_ARG(argv);
+  CHECK_ARG(this_arg);
+  CHECK_ARG(data);
+
+  v8impl::CallbackWrapper* info =
+      reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
+
+  info->Args(argv, std::min(*argc, info->ArgsLength()));
+  *argc = info->ArgsLength();
+  *this_arg = info->This();
+  *data = info->Data();
+
+  return napi_ok;
+}
+
+napi_status napi_get_cb_args_length(napi_env env,
+                                    napi_callback_info cbinfo,
+                                    size_t* result) {
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because no V8 APIs are called.
+  CHECK_ARG(result);
+
+  v8impl::CallbackWrapper* info =
+      reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
+
+  *result = info->ArgsLength();
+  return napi_ok;
+}
+
+napi_status napi_is_construct_call(napi_env env,
+                                   napi_callback_info cbinfo,
+                                   bool* result) {
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because no V8 APIs are called.
+  CHECK_ARG(result);
+
+  v8impl::CallbackWrapper* info =
+      reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
+
+  *result = info->IsConstructCall();
+  return napi_ok;
+}
+
+// copy encoded arguments into provided buffer or return direct pointer to
+// encoded arguments array?
+napi_status napi_get_cb_args(napi_env env,
+                             napi_callback_info cbinfo,
+                             napi_value* buf,
+                             size_t bufsize) {
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because no V8 APIs are called.
+  CHECK_ARG(buf);
+
+  v8impl::CallbackWrapper* info =
+      reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
+
+  info->Args(buf, bufsize);
+  return napi_ok;
+}
+
+napi_status napi_get_cb_this(napi_env env,
+                             napi_callback_info cbinfo,
+                             napi_value* result) {
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because no V8 APIs are called.
+  CHECK_ARG(result);
+
+  v8impl::CallbackWrapper* info =
+      reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
+
+  *result = info->This();
+  return napi_ok;
+}
+
+napi_status napi_get_cb_data(napi_env env,
+                             napi_callback_info cbinfo,
+                             void** result) {
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because no V8 APIs are called.
+  CHECK_ARG(result);
+
+  v8impl::CallbackWrapper* info =
+      reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
+
+  *result = info->Data();
+  return napi_ok;
+}
+
+napi_status napi_call_function(napi_env env,
+                               napi_value recv,
+                               napi_value func,
+                               size_t argc,
+                               const napi_value* argv,
+                               napi_value* result) {
+  NAPI_PREAMBLE(env);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+  v8::Local<v8::Value> v8recv = v8impl::V8LocalValueFromJsValue(recv);
+
+  v8::Local<v8::Value> v8value = v8impl::V8LocalValueFromJsValue(func);
+  RETURN_STATUS_IF_FALSE(v8value->IsFunction(), napi_invalid_arg);
+
+  v8::Local<v8::Function> v8func = v8value.As<v8::Function>();
+  auto maybe = v8func->Call(context, v8recv, argc,
+    reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(argv)));
+
+  if (try_catch.HasCaught()) {
+    return napi_set_last_error(napi_pending_exception);
+  } else {
+    if (result != nullptr) {
+      CHECK_MAYBE_EMPTY(maybe, napi_generic_failure);
+      *result = v8impl::JsValueFromV8LocalValue(maybe.ToLocalChecked());
+    }
+    return napi_ok;
+  }
+}
+
+napi_status napi_get_global(napi_env env, napi_value* result) {
+  CHECK_ARG(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  // TODO(ianhall): what if we need the global object from a different
+  // context in the same isolate?
+  // Should napi_env be the current context rather than the current isolate?
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  *result = v8impl::JsValueFromV8LocalValue(context->Global());
+
+  return napi_ok;
+}
+
+napi_status napi_throw(napi_env env, napi_value error) {
+  NAPI_PREAMBLE(env);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+
+  isolate->ThrowException(v8impl::V8LocalValueFromJsValue(error));
+  // any VM calls after this point and before returning
+  // to the javascript invoker will fail
+  return napi_ok;
+}
+
+napi_status napi_throw_error(napi_env env, const char* msg) {
+  NAPI_PREAMBLE(env);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::String> str;
+  CHECK_NEW_FROM_UTF8(isolate, str, msg);
+
+  isolate->ThrowException(v8::Exception::Error(str));
+  // any VM calls after this point and before returning
+  // to the javascript invoker will fail
+  return napi_ok;
+}
+
+napi_status napi_throw_type_error(napi_env env, const char* msg) {
+  NAPI_PREAMBLE(env);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::String> str;
+  CHECK_NEW_FROM_UTF8(isolate, str, msg);
+
+  isolate->ThrowException(v8::Exception::TypeError(str));
+  // any VM calls after this point and before returning
+  // to the javascript invoker will fail
+  return napi_ok;
+}
+
+napi_status napi_throw_range_error(napi_env env, const char* msg) {
+  NAPI_PREAMBLE(env);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::String> str;
+  CHECK_NEW_FROM_UTF8(isolate, str, msg);
+
+  isolate->ThrowException(v8::Exception::RangeError(str));
+  // any VM calls after this point and before returning
+  // to the javascript invoker will fail
+  return napi_ok;
+}
+
+napi_status napi_is_error(napi_env env, napi_value value, bool* result) {
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot
+  // throw JS exceptions.
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+  *result = val->IsNativeError();
+
+  return napi_ok;
+}
+
+napi_status napi_get_value_double(napi_env env,
+                                  napi_value value,
+                                  double* result) {
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ARG(env);
+  CHECK_ARG(value);
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+  RETURN_STATUS_IF_FALSE(val->IsNumber(), napi_number_expected);
+
+  *result = val.As<v8::Number>()->Value();
+
+  return napi_ok;
+}
+
+napi_status napi_get_value_int32(napi_env env,
+                                 napi_value value,
+                                 int32_t* result) {
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ARG(env);
+  CHECK_ARG(value);
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+  RETURN_STATUS_IF_FALSE(val->IsNumber(), napi_number_expected);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  *result = val->Int32Value(context).ToChecked();
+
+  return napi_ok;
+}
+
+napi_status napi_get_value_uint32(napi_env env,
+                                  napi_value value,
+                                  uint32_t* result) {
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ARG(env);
+  CHECK_ARG(value);
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+  RETURN_STATUS_IF_FALSE(val->IsNumber(), napi_number_expected);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  *result = val->Uint32Value(context).ToChecked();
+
+  return napi_ok;
+}
+
+napi_status napi_get_value_int64(napi_env env,
+                                 napi_value value,
+                                 int64_t* result) {
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ARG(env);
+  CHECK_ARG(value);
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+  RETURN_STATUS_IF_FALSE(val->IsNumber(), napi_number_expected);
+
+  // v8::Value::IntegerValue() converts NaN to INT64_MIN, inconsistent with
+  // v8::Value::Int32Value() that converts NaN to 0. So special-case NaN here.
+  double doubleValue = val.As<v8::Number>()->Value();
+  if (std::isnan(doubleValue)) {
+    *result = 0;
+  } else {
+    v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    *result = val->IntegerValue(context).ToChecked();
+  }
+
+  return napi_ok;
+}
+
+napi_status napi_get_value_bool(napi_env env, napi_value value, bool* result) {
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ARG(value);
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+  RETURN_STATUS_IF_FALSE(val->IsBoolean(), napi_boolean_expected);
+
+  *result = val.As<v8::Boolean>()->Value();
+
+  return napi_ok;
+}
+
+// Gets the number of CHARACTERS in the string.
+napi_status napi_get_value_string_length(napi_env env,
+                                         napi_value value,
+                                         size_t* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+  RETURN_STATUS_IF_FALSE(val->IsString(), napi_string_expected);
+
+  *result = val.As<v8::String>()->Length();
+
+  return GET_RETURN_STATUS();
+}
+
+// Copies a JavaScript string into a UTF-8 string buffer. The result is the
+// number of bytes copied into buf, including the null terminator. If bufsize
+// is insufficient, the string will be truncated, including a null terminator.
+// If buf is NULL, this method returns the length of the string (in bytes)
+// via the result parameter.
+// The result argument is optional unless buf is NULL.
+napi_status napi_get_value_string_utf8(napi_env env,
+                                       napi_value value,
+                                       char* buf,
+                                       size_t bufsize,
+                                       size_t* result) {
+  NAPI_PREAMBLE(env);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+  RETURN_STATUS_IF_FALSE(val->IsString(), napi_string_expected);
+
+  if (!buf) {
+    CHECK_ARG(result);
+    *result = val.As<v8::String>()->Utf8Length();
+  } else {
+    int copied = val.As<v8::String>()->WriteUtf8(
+      buf, bufsize, nullptr, v8::String::REPLACE_INVALID_UTF8);
+
+    if (result != nullptr) {
+      *result = copied;
+    }
+  }
+
+  return GET_RETURN_STATUS();
+}
+
+// Copies a JavaScript string into a UTF-16 string buffer. The result is the
+// number of 2-byte code units copied into buf, including the null terminator.
+// If bufsize is insufficient, the string will be truncated, including a null
+// terminator. If buf is NULL, this method returns the length of the string
+// (in 2-byte code units) via the result parameter.
+// The result argument is optional unless buf is NULL.
+napi_status napi_get_value_string_utf16(napi_env env,
+                                        napi_value value,
+                                        char16_t* buf,
+                                        size_t bufsize,
+                                        size_t* result) {
+  NAPI_PREAMBLE(env);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+  RETURN_STATUS_IF_FALSE(val->IsString(), napi_string_expected);
+
+  if (!buf) {
+    CHECK_ARG(result);
+    // V8 assumes UTF-16 length is the same as the number of characters.
+    *result = val.As<v8::String>()->Length();
+  } else {
+    int copied = val.As<v8::String>()->Write(
+      reinterpret_cast<uint16_t*>(buf), 0, bufsize, v8::String::NO_OPTIONS);
+
+    if (result != nullptr) {
+      *result = copied;
+    }
+  }
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_coerce_to_object(napi_env env,
+                                  napi_value value,
+                                  napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Object> obj;
+  CHECK_TO_OBJECT(context, obj, value);
+
+  *result = v8impl::JsValueFromV8LocalValue(obj);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_coerce_to_bool(napi_env env,
+                                napi_value value,
+                                napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Boolean> b;
+
+  CHECK_TO_BOOL(context, b, value);
+
+  *result = v8impl::JsValueFromV8LocalValue(b);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_coerce_to_number(napi_env env,
+                                  napi_value value,
+                                  napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Number> num;
+
+  CHECK_TO_NUMBER(context, num, value);
+
+  *result = v8impl::JsValueFromV8LocalValue(num);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_coerce_to_string(napi_env env,
+                                  napi_value value,
+                                  napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::String> str;
+
+  CHECK_TO_STRING(context, str, value);
+
+  *result = v8impl::JsValueFromV8LocalValue(str);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_wrap(napi_env env,
+                      napi_value js_object,
+                      void* native_object,
+                      napi_finalize finalize_cb,
+                      void* finalize_hint,
+                      napi_ref* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(js_object);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Object> obj =
+      v8impl::V8LocalValueFromJsValue(js_object).As<v8::Object>();
+
+  // Only objects that were created from a NAPI constructor's prototype
+  // via napi_define_class() can be (un)wrapped.
+  RETURN_STATUS_IF_FALSE(obj->InternalFieldCount() > 0, napi_invalid_arg);
+
+  obj->SetInternalField(0, v8::External::New(isolate, native_object));
+
+  if (result != nullptr) {
+    // The returned reference should be deleted via napi_delete_reference()
+    // ONLY in response to the finalize callback invocation. (If it is deleted
+    // before then, then the finalize callback will never be invoked.)
+    // Therefore a finalize callback is required when returning a reference.
+    CHECK_ARG(finalize_cb);
+    v8impl::Reference* reference = v8impl::Reference::New(
+        isolate, obj, 0, false, finalize_cb, native_object, finalize_hint);
+    *result = reinterpret_cast<napi_ref>(reference);
+  } else if (finalize_cb != nullptr) {
+    // Create a self-deleting reference just for the finalize callback.
+    v8impl::Reference::New(
+        isolate, obj, 0, true, finalize_cb, native_object, finalize_hint);
+  }
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_unwrap(napi_env env, napi_value js_object, void** result) {
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ARG(js_object);
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(js_object);
+  RETURN_STATUS_IF_FALSE(value->IsObject(), napi_invalid_arg);
+  v8::Local<v8::Object> obj = value.As<v8::Object>();
+
+  // Only objects that were created from a NAPI constructor's prototype
+  // via napi_define_class() can be (un)wrapped.
+  RETURN_STATUS_IF_FALSE(obj->InternalFieldCount() > 0, napi_invalid_arg);
+
+  v8::Local<v8::Value> unwrappedValue = obj->GetInternalField(0);
+  RETURN_STATUS_IF_FALSE(unwrappedValue->IsExternal(), napi_invalid_arg);
+
+  *result = unwrappedValue.As<v8::External>()->Value();
+
+  return napi_ok;
+}
+
+napi_status napi_create_external(napi_env env,
+                                 void* data,
+                                 napi_finalize finalize_cb,
+                                 void* finalize_hint,
+                                 napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+
+  v8::Local<v8::Value> external_value = v8::External::New(isolate, data);
+
+  // The Reference object will delete itself after invoking the finalizer
+  // callback.
+  v8impl::Reference::New(isolate,
+      external_value,
+      0,
+      true,
+      finalize_cb,
+      data,
+      finalize_hint);
+
+  *result = v8impl::JsValueFromV8LocalValue(external_value);
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_get_value_external(napi_env env,
+                                    napi_value value,
+                                    void** result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(value);
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+  RETURN_STATUS_IF_FALSE(val->IsExternal(), napi_invalid_arg);
+
+  v8::Local<v8::External> external_value = val.As<v8::External>();
+  *result = external_value->Value();
+
+  return GET_RETURN_STATUS();
+}
+
+// Set initial_refcount to 0 for a weak reference, >0 for a strong reference.
+napi_status napi_create_reference(napi_env env,
+                                  napi_value value,
+                                  uint32_t initial_refcount,
+                                  napi_ref* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+
+  v8impl::Reference* reference = v8impl::Reference::New(
+      isolate, v8impl::V8LocalValueFromJsValue(value), initial_refcount, false);
+
+  *result = reinterpret_cast<napi_ref>(reference);
+  return GET_RETURN_STATUS();
+}
+
+// Deletes a reference. The referenced value is released, and may be GC'd unless
+// there are other references to it.
+napi_status napi_delete_reference(napi_env env, napi_ref ref) {
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ARG(ref);
+
+  v8impl::Reference::Delete(reinterpret_cast<v8impl::Reference*>(ref));
+
+  return napi_ok;
+}
+
+// Increments the reference count, optionally returning the resulting count.
+// After this call the reference will be a strong reference because its
+// refcount is >0, and the referenced object is effectively "pinned".
+// Calling this when the refcount is 0 and the object is unavailable
+// results in an error.
+napi_status napi_reference_ref(napi_env env, napi_ref ref, uint32_t* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(ref);
+
+  v8impl::Reference* reference = reinterpret_cast<v8impl::Reference*>(ref);
+  uint32_t count = reference->Ref();
+
+  if (result != nullptr) {
+    *result = count;
+  }
+
+  return GET_RETURN_STATUS();
+}
+
+// Decrements the reference count, optionally returning the resulting count. If
+// the result is 0 the reference is now weak and the object may be GC'd at any
+// time if there are no other references. Calling this when the refcount is
+// already 0 results in an error.
+napi_status napi_reference_unref(napi_env env, napi_ref ref, uint32_t* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(ref);
+
+  v8impl::Reference* reference = reinterpret_cast<v8impl::Reference*>(ref);
+
+  if (reference->RefCount() == 0) {
+    return napi_set_last_error(napi_generic_failure);
+  }
+
+  uint32_t count = reference->Unref();
+
+  if (result != nullptr) {
+    *result = count;
+  }
+
+  return GET_RETURN_STATUS();
+}
+
+// Attempts to get a referenced value. If the reference is weak, the value might
+// no longer be available, in that case the call is still successful but the
+// result is NULL.
+napi_status napi_get_reference_value(napi_env env,
+                                     napi_ref ref,
+                                     napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(ref);
+  CHECK_ARG(result);
+
+  v8impl::Reference* reference = reinterpret_cast<v8impl::Reference*>(ref);
+  *result = v8impl::JsValueFromV8LocalValue(reference->Get());
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_open_handle_scope(napi_env env, napi_handle_scope* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  *result = v8impl::JsHandleScopeFromV8HandleScope(
+      new v8impl::HandleScopeWrapper(v8impl::V8IsolateFromJsEnv(env)));
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_close_handle_scope(napi_env env, napi_handle_scope scope) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(scope);
+
+  delete v8impl::V8HandleScopeFromJsHandleScope(scope);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_open_escapable_handle_scope(
+    napi_env env,
+    napi_escapable_handle_scope* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  *result = v8impl::JsEscapableHandleScopeFromV8EscapableHandleScope(
+      new v8impl::EscapableHandleScopeWrapper(v8impl::V8IsolateFromJsEnv(env)));
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_close_escapable_handle_scope(
+    napi_env env,
+    napi_escapable_handle_scope scope) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(scope);
+
+  delete v8impl::V8EscapableHandleScopeFromJsEscapableHandleScope(scope);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_escape_handle(napi_env env,
+                               napi_escapable_handle_scope scope,
+                               napi_value escapee,
+                               napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(scope);
+  CHECK_ARG(result);
+
+  v8impl::EscapableHandleScopeWrapper* s =
+      v8impl::V8EscapableHandleScopeFromJsEscapableHandleScope(scope);
+  *result = v8impl::JsValueFromV8LocalValue(
+      s->Escape(v8impl::V8LocalValueFromJsValue(escapee)));
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_new_instance(napi_env env,
+                              napi_value constructor,
+                              size_t argc,
+                              const napi_value* argv,
+                              napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+  v8::Local<v8::Value> v8value = v8impl::V8LocalValueFromJsValue(constructor);
+  RETURN_STATUS_IF_FALSE(v8value->IsFunction(), napi_invalid_arg);
+
+  v8::Local<v8::Function> ctor = v8value.As<v8::Function>();
+
+  auto maybe = ctor->NewInstance(context, argc,
+    reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(argv)));
+
+  CHECK_MAYBE_EMPTY(maybe, napi_generic_failure);
+
+  *result = v8impl::JsValueFromV8LocalValue(maybe.ToLocalChecked());
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_instanceof(napi_env env,
+                            napi_value object,
+                            napi_value constructor,
+                            bool* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  *result = false;
+
+  v8::Local<v8::Object> ctor;
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+  CHECK_TO_OBJECT(context, ctor, constructor);
+
+  if (!ctor->IsFunction()) {
+    napi_throw_type_error(env, "constructor must be a function");
+
+    return napi_set_last_error(napi_function_expected);
+  }
+
+  napi_value value, js_result;
+  napi_status status;
+  napi_valuetype value_type;
+
+  // Get "Symbol" from the global object
+  status = napi_get_global(env, &value);
+  if (status != napi_ok) return status;
+  status = napi_get_named_property(env, value, "Symbol", &value);
+  if (status != napi_ok) return status;
+  status = napi_typeof(env, value, &value_type);
+  if (status != napi_ok) return status;
+
+  // Get "hasInstance" from Symbol
+  if (value_type == napi_function) {
+    status = napi_get_named_property(env, value, "hasInstance", &value);
+    if (status != napi_ok) return status;
+    status = napi_typeof(env, value, &value_type);
+    if (status != napi_ok) return status;
+
+    // Retrieve the function at the Symbol(hasInstance) key of the constructor
+    if (value_type == napi_symbol) {
+      status = napi_get_property(env, constructor, value, &value);
+      if (status != napi_ok) return status;
+      status = napi_typeof(env, value, &value_type);
+      if (status != napi_ok) return status;
+
+      // Call the function to determine whether the object is an instance of the
+      // constructor
+      if (value_type == napi_function) {
+        status = napi_call_function(env, constructor, value, 1, &object,
+          &js_result);
+        if (status != napi_ok) return status;
+        return napi_get_value_bool(env, js_result, result);
+      }
+    }
+  }
+
+  // If running constructor[Symbol.hasInstance](object) did not work, we perform
+  // a traditional instanceof (early Node.js 6.x).
+
+  v8::Local<v8::String> prototype_string;
+  CHECK_NEW_FROM_UTF8(isolate, prototype_string, "prototype");
+
+  auto maybe_prototype = ctor->Get(context, prototype_string);
+  CHECK_MAYBE_EMPTY(maybe_prototype, napi_generic_failure);
+
+  v8::Local<v8::Value> prototype_property = maybe_prototype.ToLocalChecked();
+  if (!prototype_property->IsObject()) {
+    napi_throw_type_error(env, "constructor.prototype must be an object");
+
+    return napi_set_last_error(napi_object_expected);
+  }
+
+  auto maybe_ctor = prototype_property->ToObject(context);
+  CHECK_MAYBE_EMPTY(maybe_ctor, napi_generic_failure);
+  ctor = maybe_ctor.ToLocalChecked();
+
+  v8::Local<v8::Value> current_obj = v8impl::V8LocalValueFromJsValue(object);
+  if (!current_obj->StrictEquals(ctor)) {
+    for (v8::Local<v8::Value> original_obj = current_obj;
+         !(current_obj->IsNull() || current_obj->IsUndefined());) {
+      if (current_obj->StrictEquals(ctor)) {
+        *result = !(original_obj->IsNumber() ||
+                    original_obj->IsBoolean() ||
+                    original_obj->IsString());
+        break;
+      }
+      v8::Local<v8::Object> obj;
+      CHECK_TO_OBJECT(context, obj, v8impl::JsValueFromV8LocalValue(
+        current_obj));
+      current_obj = obj->GetPrototype();
+    }
+  }
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_make_callback(napi_env env,
+                               napi_value recv,
+                               napi_value func,
+                               size_t argc,
+                               const napi_value* argv,
+                               napi_value* result) {
+  NAPI_PREAMBLE(env);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::Object> v8recv =
+      v8impl::V8LocalValueFromJsValue(recv).As<v8::Object>();
+  v8::Local<v8::Function> v8func =
+      v8impl::V8LocalValueFromJsValue(func).As<v8::Function>();
+
+  v8::Local<v8::Value> callback_result = node::MakeCallback(
+      isolate, v8recv, v8func, argc,
+      reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(argv)));
+
+  if (result != nullptr) {
+    *result = v8impl::JsValueFromV8LocalValue(callback_result);
+  }
+
+  return GET_RETURN_STATUS();
+}
+
+// Methods to support catching exceptions
+napi_status napi_is_exception_pending(napi_env env, bool* result) {
+  // NAPI_PREAMBLE is not used here: this function must execute when there is a
+  // pending exception.
+  CHECK_ARG(env);
+  CHECK_ARG(result);
+
+  *result = !v8impl::TryCatch::LastException().IsEmpty();
+  return napi_ok;
+}
+
+napi_status napi_get_and_clear_last_exception(napi_env env,
+                                              napi_value* result) {
+  // NAPI_PREAMBLE is not used here: this function must execute when there is a
+  // pending exception.
+  CHECK_ARG(env);
+  CHECK_ARG(result);
+
+  if (v8impl::TryCatch::LastException().IsEmpty()) {
+    return napi_get_undefined(env, result);
+  } else {
+    *result = v8impl::JsValueFromV8LocalValue(v8::Local<v8::Value>::New(
+        v8impl::V8IsolateFromJsEnv(env), v8impl::TryCatch::LastException()));
+    v8impl::TryCatch::LastException().Reset();
+  }
+
+  return napi_ok;
+}
+
+napi_status napi_create_buffer(napi_env env,
+                               size_t length,
+                               void** data,
+                               napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(data);
+  CHECK_ARG(result);
+
+  auto maybe = node::Buffer::New(v8impl::V8IsolateFromJsEnv(env), length);
+
+  CHECK_MAYBE_EMPTY(maybe, napi_generic_failure);
+
+  v8::Local<v8::Object> buffer = maybe.ToLocalChecked();
+
+  *result = v8impl::JsValueFromV8LocalValue(buffer);
+  *data = node::Buffer::Data(buffer);
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_create_external_buffer(napi_env env,
+                                        size_t length,
+                                        void* data,
+                                        napi_finalize finalize_cb,
+                                        void* finalize_hint,
+                                        napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+
+  // The finalizer object will delete itself after invoking the callback.
+  v8impl::Finalizer* finalizer = v8impl::Finalizer::New(
+    isolate, finalize_cb, nullptr, finalize_hint);
+
+  auto maybe = node::Buffer::New(isolate,
+                                 static_cast<char*>(data),
+                                 length,
+                                 v8impl::Finalizer::FinalizeBufferCallback,
+                                 finalizer);
+
+  CHECK_MAYBE_EMPTY(maybe, napi_generic_failure);
+
+  *result = v8impl::JsValueFromV8LocalValue(maybe.ToLocalChecked());
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_create_buffer_copy(napi_env env,
+                                    size_t length,
+                                    const void* data,
+                                    void** result_data,
+                                    napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  auto maybe = node::Buffer::Copy(v8impl::V8IsolateFromJsEnv(env),
+    static_cast<const char*>(data), length);
+
+  CHECK_MAYBE_EMPTY(maybe, napi_generic_failure);
+
+  v8::Local<v8::Object> buffer = maybe.ToLocalChecked();
+  *result = v8impl::JsValueFromV8LocalValue(buffer);
+
+  if (result_data != nullptr) {
+    *result_data = node::Buffer::Data(buffer);
+  }
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_is_buffer(napi_env env, napi_value value, bool* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  *result = node::Buffer::HasInstance(v8impl::V8LocalValueFromJsValue(value));
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_get_buffer_info(napi_env env,
+                                 napi_value value,
+                                 void** data,
+                                 size_t* length) {
+  NAPI_PREAMBLE(env);
+
+  v8::Local<v8::Object> buffer =
+      v8impl::V8LocalValueFromJsValue(value).As<v8::Object>();
+
+  if (data != nullptr) {
+    *data = node::Buffer::Data(buffer);
+  }
+  if (length != nullptr) {
+    *length = node::Buffer::Length(buffer);
+  }
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_is_arraybuffer(napi_env env, napi_value value, bool* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+  *result = val->IsArrayBuffer();
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_create_arraybuffer(napi_env env,
+                                    size_t byte_length,
+                                    void** data,
+                                    napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::ArrayBuffer> buffer =
+      v8::ArrayBuffer::New(isolate, byte_length);
+
+  // Optionally return a pointer to the buffer's data, to avoid another call to
+  // retreive it.
+  if (data != nullptr) {
+    *data = buffer->GetContents().Data();
+  }
+
+  *result = v8impl::JsValueFromV8LocalValue(buffer);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_create_external_arraybuffer(napi_env env,
+                                             void* external_data,
+                                             size_t byte_length,
+                                             napi_finalize finalize_cb,
+                                             void* finalize_hint,
+                                             napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Local<v8::ArrayBuffer> buffer =
+      v8::ArrayBuffer::New(isolate, external_data, byte_length);
+
+  if (finalize_cb != nullptr) {
+    // Create a self-deleting weak reference that invokes the finalizer
+    // callback.
+    v8impl::Reference::New(isolate,
+        buffer,
+        0,
+        true,
+        finalize_cb,
+        external_data,
+        finalize_hint);
+  }
+
+  *result = v8impl::JsValueFromV8LocalValue(buffer);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_get_arraybuffer_info(napi_env env,
+                                      napi_value arraybuffer,
+                                      void** data,
+                                      size_t* byte_length) {
+  NAPI_PREAMBLE(env);
+
+  v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(arraybuffer);
+  RETURN_STATUS_IF_FALSE(value->IsArrayBuffer(), napi_invalid_arg);
+
+  v8::ArrayBuffer::Contents contents =
+      value.As<v8::ArrayBuffer>()->GetContents();
+
+  if (data != nullptr) {
+    *data = contents.Data();
+  }
+
+  if (byte_length != nullptr) {
+    *byte_length = contents.ByteLength();
+  }
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_is_typedarray(napi_env env, napi_value value, bool* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+  *result = val->IsTypedArray();
+
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_create_typedarray(napi_env env,
+                                   napi_typedarray_type type,
+                                   size_t length,
+                                   napi_value arraybuffer,
+                                   size_t byte_offset,
+                                   napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(result);
+
+  v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(arraybuffer);
+  RETURN_STATUS_IF_FALSE(value->IsArrayBuffer(), napi_invalid_arg);
+
+  v8::Local<v8::ArrayBuffer> buffer = value.As<v8::ArrayBuffer>();
+  v8::Local<v8::TypedArray> typedArray;
+
+  switch (type) {
+    case napi_int8_array:
+      typedArray = v8::Int8Array::New(buffer, byte_offset, length);
+      break;
+    case napi_uint8_array:
+      typedArray = v8::Uint8Array::New(buffer, byte_offset, length);
+      break;
+    case napi_uint8_clamped_array:
+      typedArray = v8::Uint8ClampedArray::New(buffer, byte_offset, length);
+      break;
+    case napi_int16_array:
+      typedArray = v8::Int16Array::New(buffer, byte_offset, length);
+      break;
+    case napi_uint16_array:
+      typedArray = v8::Uint16Array::New(buffer, byte_offset, length);
+      break;
+    case napi_int32_array:
+      typedArray = v8::Int32Array::New(buffer, byte_offset, length);
+      break;
+    case napi_uint32_array:
+      typedArray = v8::Uint32Array::New(buffer, byte_offset, length);
+      break;
+    case napi_float32_array:
+      typedArray = v8::Float32Array::New(buffer, byte_offset, length);
+      break;
+    case napi_float64_array:
+      typedArray = v8::Float64Array::New(buffer, byte_offset, length);
+      break;
+    default:
+      return napi_set_last_error(napi_invalid_arg);
+  }
+
+  *result = v8impl::JsValueFromV8LocalValue(typedArray);
+  return GET_RETURN_STATUS();
+}
+
+napi_status napi_get_typedarray_info(napi_env env,
+                                     napi_value typedarray,
+                                     napi_typedarray_type* type,
+                                     size_t* length,
+                                     void** data,
+                                     napi_value* arraybuffer,
+                                     size_t* byte_offset) {
+  NAPI_PREAMBLE(env);
+
+  v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(typedarray);
+  RETURN_STATUS_IF_FALSE(value->IsTypedArray(), napi_invalid_arg);
+
+  v8::Local<v8::TypedArray> array = value.As<v8::TypedArray>();
+
+  if (type != nullptr) {
+    if (value->IsInt8Array()) {
+      *type = napi_int8_array;
+    } else if (value->IsUint8Array()) {
+      *type = napi_uint8_array;
+    } else if (value->IsUint8ClampedArray()) {
+      *type = napi_uint8_clamped_array;
+    } else if (value->IsInt16Array()) {
+      *type = napi_int16_array;
+    } else if (value->IsUint16Array()) {
+      *type = napi_uint16_array;
+    } else if (value->IsInt32Array()) {
+      *type = napi_int32_array;
+    } else if (value->IsUint32Array()) {
+      *type = napi_uint32_array;
+    } else if (value->IsFloat32Array()) {
+      *type = napi_float32_array;
+    } else if (value->IsFloat64Array()) {
+      *type = napi_float64_array;
+    }
+  }
+
+  if (length != nullptr) {
+    *length = array->Length();
+  }
+
+  v8::Local<v8::ArrayBuffer> buffer = array->Buffer();
+  if (data != nullptr) {
+    *data = static_cast<uint8_t*>(buffer->GetContents().Data()) +
+            array->ByteOffset();
+  }
+
+  if (arraybuffer != nullptr) {
+    *arraybuffer = v8impl::JsValueFromV8LocalValue(buffer);
+  }
+
+  if (byte_offset != nullptr) {
+    *byte_offset = array->ByteOffset();
+  }
+
+  return GET_RETURN_STATUS();
+}
diff --git a/src/node_api.h b/src/node_api.h
new file mode 100644
index 00000000000000..da14a01654b844
--- /dev/null
+++ b/src/node_api.h
@@ -0,0 +1,479 @@
+/******************************************************************************
+ * Experimental prototype for demonstrating VM agnostic and ABI stable API
+ * for native modules to use instead of using Nan and V8 APIs directly.
+ *
+ * The current status is "Experimental" and should not be used for
+ * production applications.  The API is still subject to change
+ * and as an experimental feature is NOT subject to semver.
+ *
+ ******************************************************************************/
+#ifndef SRC_NODE_API_H_
+#define SRC_NODE_API_H_
+
+#include <stddef.h>
+#include <stdbool.h>
+#include "node_api_types.h"
+
+#ifdef _WIN32
+  #ifdef BUILDING_NODE_EXTENSION
+    #ifdef EXTERNAL_NAPI
+      // Building external N-API, or native module against external N-API
+      #define NAPI_EXTERN /* nothing */
+    #else
+      // Building native module against node with built-in N-API
+      #define NAPI_EXTERN __declspec(dllimport)
+    #endif
+  #else
+    // Building node with built-in N-API
+    #define NAPI_EXTERN __declspec(dllexport)
+  #endif
+#else
+  #define NAPI_EXTERN /* nothing */
+#endif
+
+#ifdef _WIN32
+# define NAPI_MODULE_EXPORT __declspec(dllexport)
+#else
+# define NAPI_MODULE_EXPORT __attribute__((visibility("default")))
+#endif
+
+
+typedef void (*napi_addon_register_func)(napi_env env,
+                                         napi_value exports,
+                                         napi_value module,
+                                         void* priv);
+
+typedef struct {
+  int nm_version;
+  unsigned int nm_flags;
+  const char* nm_filename;
+  napi_addon_register_func nm_register_func;
+  const char* nm_modname;
+  void* nm_priv;
+  void* reserved[4];
+} napi_module;
+
+#define NAPI_MODULE_VERSION  1
+
+#if defined(_MSC_VER)
+#pragma section(".CRT$XCU", read)
+#define NAPI_C_CTOR(fn)                                                     \
+  static void __cdecl fn(void);                                             \
+  __declspec(dllexport, allocate(".CRT$XCU")) void(__cdecl * fn##_)(void) = \
+      fn;                                                                   \
+  static void __cdecl fn(void)
+#else
+#define NAPI_C_CTOR(fn)                              \
+  static void fn(void) __attribute__((constructor)); \
+  static void fn(void)
+#endif
+
+#ifdef __cplusplus
+#define EXTERN_C_START extern "C" {
+#define EXTERN_C_END }
+#else
+#define EXTERN_C_START
+#define EXTERN_C_END
+#endif
+
+#define NAPI_MODULE_X(modname, regfunc, priv, flags)                  \
+  EXTERN_C_START                                                      \
+    static napi_module _module =                                      \
+    {                                                                 \
+      NAPI_MODULE_VERSION,                                            \
+      flags,                                                          \
+      __FILE__,                                                       \
+      regfunc,                                                        \
+      #modname,                                                       \
+      priv,                                                           \
+      {0},                                                            \
+    };                                                                \
+    NAPI_C_CTOR(_register_ ## modname) {                              \
+      napi_module_register(&_module);                                 \
+    }                                                                 \
+  EXTERN_C_END
+
+#define NAPI_MODULE(modname, regfunc) \
+  NAPI_MODULE_X(modname, regfunc, NULL, 0)
+
+EXTERN_C_START
+
+NAPI_EXTERN void napi_module_register(napi_module* mod);
+
+NAPI_EXTERN napi_status
+napi_get_last_error_info(napi_env env,
+                         const napi_extended_error_info** result);
+
+// Getters for defined singletons
+NAPI_EXTERN napi_status napi_get_undefined(napi_env env, napi_value* result);
+NAPI_EXTERN napi_status napi_get_null(napi_env env, napi_value* result);
+NAPI_EXTERN napi_status napi_get_global(napi_env env, napi_value* result);
+NAPI_EXTERN napi_status napi_get_boolean(napi_env env,
+                                         bool value,
+                                         napi_value* result);
+
+// Methods to create Primitive types/Objects
+NAPI_EXTERN napi_status napi_create_object(napi_env env, napi_value* result);
+NAPI_EXTERN napi_status napi_create_array(napi_env env, napi_value* result);
+NAPI_EXTERN napi_status napi_create_array_with_length(napi_env env,
+                                                      size_t length,
+                                                      napi_value* result);
+NAPI_EXTERN napi_status napi_create_number(napi_env env,
+                                           double value,
+                                           napi_value* result);
+NAPI_EXTERN napi_status napi_create_string_utf8(napi_env env,
+                                                const char* str,
+                                                size_t length,
+                                                napi_value* result);
+NAPI_EXTERN napi_status napi_create_string_utf16(napi_env env,
+                                                 const char16_t* str,
+                                                 size_t length,
+                                                 napi_value* result);
+NAPI_EXTERN napi_status napi_create_symbol(napi_env env,
+                                           napi_value description,
+                                           napi_value* result);
+NAPI_EXTERN napi_status napi_create_function(napi_env env,
+                                             const char* utf8name,
+                                             napi_callback cb,
+                                             void* data,
+                                             napi_value* result);
+NAPI_EXTERN napi_status napi_create_error(napi_env env,
+                                          napi_value msg,
+                                          napi_value* result);
+NAPI_EXTERN napi_status napi_create_type_error(napi_env env,
+                                               napi_value msg,
+                                               napi_value* result);
+NAPI_EXTERN napi_status napi_create_range_error(napi_env env,
+                                                napi_value msg,
+                                                napi_value* result);
+
+// Methods to get the the native napi_value from Primitive type
+NAPI_EXTERN napi_status napi_typeof(napi_env env,
+                                    napi_value value,
+                                    napi_valuetype* result);
+NAPI_EXTERN napi_status napi_get_value_double(napi_env env,
+                                              napi_value value,
+                                              double* result);
+NAPI_EXTERN napi_status napi_get_value_int32(napi_env env,
+                                             napi_value value,
+                                             int32_t* result);
+NAPI_EXTERN napi_status napi_get_value_uint32(napi_env env,
+                                              napi_value value,
+                                              uint32_t* result);
+NAPI_EXTERN napi_status napi_get_value_int64(napi_env env,
+                                             napi_value value,
+                                             int64_t* result);
+NAPI_EXTERN napi_status napi_get_value_bool(napi_env env,
+                                            napi_value value,
+                                            bool* result);
+
+// Gets the number of CHARACTERS in the string.
+NAPI_EXTERN napi_status napi_get_value_string_length(napi_env env,
+                                                     napi_value value,
+                                                     size_t* result);
+
+// Copies UTF-8 encoded bytes from a string into a buffer.
+NAPI_EXTERN napi_status napi_get_value_string_utf8(napi_env env,
+                                                   napi_value value,
+                                                   char* buf,
+                                                   size_t bufsize,
+                                                   size_t* result);
+
+// Copies UTF-16 encoded bytes from a string into a buffer.
+NAPI_EXTERN napi_status napi_get_value_string_utf16(napi_env env,
+                                                    napi_value value,
+                                                    char16_t* buf,
+                                                    size_t bufsize,
+                                                    size_t* result);
+
+// Methods to coerce values
+// These APIs may execute user scripts
+NAPI_EXTERN napi_status napi_coerce_to_bool(napi_env env,
+                                            napi_value value,
+                                            napi_value* result);
+NAPI_EXTERN napi_status napi_coerce_to_number(napi_env env,
+                                              napi_value value,
+                                              napi_value* result);
+NAPI_EXTERN napi_status napi_coerce_to_object(napi_env env,
+                                              napi_value value,
+                                              napi_value* result);
+NAPI_EXTERN napi_status napi_coerce_to_string(napi_env env,
+                                              napi_value value,
+                                              napi_value* result);
+
+// Methods to work with Objects
+NAPI_EXTERN napi_status napi_get_prototype(napi_env env,
+                                           napi_value object,
+                                           napi_value* result);
+NAPI_EXTERN napi_status napi_get_property_names(napi_env env,
+                                                napi_value object,
+                                                napi_value* result);
+NAPI_EXTERN napi_status napi_set_property(napi_env env,
+                                          napi_value object,
+                                          napi_value key,
+                                          napi_value value);
+NAPI_EXTERN napi_status napi_has_property(napi_env env,
+                                          napi_value object,
+                                          napi_value key,
+                                          bool* result);
+NAPI_EXTERN napi_status napi_get_property(napi_env env,
+                                          napi_value object,
+                                          napi_value key,
+                                          napi_value* result);
+NAPI_EXTERN napi_status napi_set_named_property(napi_env env,
+                                          napi_value object,
+                                          const char* utf8name,
+                                          napi_value value);
+NAPI_EXTERN napi_status napi_has_named_property(napi_env env,
+                                          napi_value object,
+                                          const char* utf8name,
+                                          bool* result);
+NAPI_EXTERN napi_status napi_get_named_property(napi_env env,
+                                          napi_value object,
+                                          const char* utf8name,
+                                          napi_value* result);
+NAPI_EXTERN napi_status napi_set_element(napi_env env,
+                                         napi_value object,
+                                         uint32_t index,
+                                         napi_value value);
+NAPI_EXTERN napi_status napi_has_element(napi_env env,
+                                         napi_value object,
+                                         uint32_t index,
+                                         bool* result);
+NAPI_EXTERN napi_status napi_get_element(napi_env env,
+                                         napi_value object,
+                                         uint32_t index,
+                                         napi_value* result);
+NAPI_EXTERN napi_status
+napi_define_properties(napi_env env,
+                       napi_value object,
+                       size_t property_count,
+                       const napi_property_descriptor* properties);
+
+// Methods to work with Arrays
+NAPI_EXTERN napi_status napi_is_array(napi_env env,
+                                      napi_value value,
+                                      bool* result);
+NAPI_EXTERN napi_status napi_get_array_length(napi_env env,
+                                              napi_value value,
+                                              uint32_t* result);
+
+// Methods to compare values
+NAPI_EXTERN napi_status napi_strict_equals(napi_env env,
+                                           napi_value lhs,
+                                           napi_value rhs,
+                                           bool* result);
+
+// Methods to work with Functions
+NAPI_EXTERN napi_status napi_call_function(napi_env env,
+                                           napi_value recv,
+                                           napi_value func,
+                                           size_t argc,
+                                           const napi_value* argv,
+                                           napi_value* result);
+NAPI_EXTERN napi_status napi_new_instance(napi_env env,
+                                          napi_value constructor,
+                                          size_t argc,
+                                          const napi_value* argv,
+                                          napi_value* result);
+NAPI_EXTERN napi_status napi_instanceof(napi_env env,
+                                        napi_value object,
+                                        napi_value constructor,
+                                        bool* result);
+
+// Napi version of node::MakeCallback(...)
+NAPI_EXTERN napi_status napi_make_callback(napi_env env,
+                                           napi_value recv,
+                                           napi_value func,
+                                           size_t argc,
+                                           const napi_value* argv,
+                                           napi_value* result);
+
+// Methods to work with napi_callbacks
+
+// Gets all callback info in a single call. (Ugly, but faster.)
+NAPI_EXTERN napi_status napi_get_cb_info(
+    napi_env env,               // [in] NAPI environment handle
+    napi_callback_info cbinfo,  // [in] Opaque callback-info handle
+    size_t* argc,      // [in-out] Specifies the size of the provided argv array
+                       // and receives the actual count of args.
+    napi_value* argv,  // [out] Array of values
+    napi_value* thisArg,  // [out] Receives the JS 'this' arg for the call
+    void** data);         // [out] Receives the data pointer for the callback.
+
+NAPI_EXTERN napi_status napi_get_cb_args_length(napi_env env,
+                                                napi_callback_info cbinfo,
+                                                size_t* result);
+NAPI_EXTERN napi_status napi_get_cb_args(napi_env env,
+                                         napi_callback_info cbinfo,
+                                         napi_value* buf,
+                                         size_t bufsize);
+NAPI_EXTERN napi_status napi_get_cb_this(napi_env env,
+                                         napi_callback_info cbinfo,
+                                         napi_value* result);
+
+NAPI_EXTERN napi_status napi_get_cb_data(napi_env env,
+                                         napi_callback_info cbinfo,
+                                         void** result);
+NAPI_EXTERN napi_status napi_is_construct_call(napi_env env,
+                                               napi_callback_info cbinfo,
+                                               bool* result);
+NAPI_EXTERN napi_status napi_set_return_value(napi_env env,
+                                              napi_callback_info cbinfo,
+                                              napi_value value);
+NAPI_EXTERN napi_status
+napi_define_class(napi_env env,
+                  const char* utf8name,
+                  napi_callback constructor,
+                  void* data,
+                  size_t property_count,
+                  const napi_property_descriptor* properties,
+                  napi_value* result);
+
+// Methods to work with external data objects
+NAPI_EXTERN napi_status napi_wrap(napi_env env,
+                                  napi_value js_object,
+                                  void* native_object,
+                                  napi_finalize finalize_cb,
+                                  void* finalize_hint,
+                                  napi_ref* result);
+NAPI_EXTERN napi_status napi_unwrap(napi_env env,
+                                    napi_value js_object,
+                                    void** result);
+NAPI_EXTERN napi_status napi_create_external(napi_env env,
+                                             void* data,
+                                             napi_finalize finalize_cb,
+                                             void* finalize_hint,
+                                             napi_value* result);
+NAPI_EXTERN napi_status napi_get_value_external(napi_env env,
+                                                napi_value value,
+                                                void** result);
+
+// Methods to control object lifespan
+
+// Set initial_refcount to 0 for a weak reference, >0 for a strong reference.
+NAPI_EXTERN napi_status napi_create_reference(napi_env env,
+                                              napi_value value,
+                                              uint32_t initial_refcount,
+                                              napi_ref* result);
+
+// Deletes a reference. The referenced value is released, and may
+// be GC'd unless there are other references to it.
+NAPI_EXTERN napi_status napi_delete_reference(napi_env env, napi_ref ref);
+
+// Increments the reference count, optionally returning the resulting count.
+// After this call the  reference will be a strong reference because its
+// refcount is >0, and the referenced object is effectively "pinned".
+// Calling this when the refcount is 0 and the object is unavailable
+// results in an error.
+NAPI_EXTERN napi_status napi_reference_ref(napi_env env,
+                                           napi_ref ref,
+                                           uint32_t* result);
+
+// Decrements the reference count, optionally returning the resulting count.
+// If the result is 0 the reference is now weak and the object may be GC'd
+// at any time if there are no other references. Calling this when the
+// refcount is already 0 results in an error.
+NAPI_EXTERN napi_status napi_reference_unref(napi_env env,
+                                             napi_ref ref,
+                                             uint32_t* result);
+
+// Attempts to get a referenced value. If the reference is weak,
+// the value might no longer be available, in that case the call
+// is still successful but the result is NULL.
+NAPI_EXTERN napi_status napi_get_reference_value(napi_env env,
+                                                 napi_ref ref,
+                                                 napi_value* result);
+
+NAPI_EXTERN napi_status napi_open_handle_scope(napi_env env,
+                                               napi_handle_scope* result);
+NAPI_EXTERN napi_status napi_close_handle_scope(napi_env env,
+                                                napi_handle_scope scope);
+NAPI_EXTERN napi_status
+napi_open_escapable_handle_scope(napi_env env,
+                                 napi_escapable_handle_scope* result);
+NAPI_EXTERN napi_status
+napi_close_escapable_handle_scope(napi_env env,
+                                  napi_escapable_handle_scope scope);
+
+NAPI_EXTERN napi_status napi_escape_handle(napi_env env,
+                                           napi_escapable_handle_scope scope,
+                                           napi_value escapee,
+                                           napi_value* result);
+
+// Methods to support error handling
+NAPI_EXTERN napi_status napi_throw(napi_env env, napi_value error);
+NAPI_EXTERN napi_status napi_throw_error(napi_env env, const char* msg);
+NAPI_EXTERN napi_status napi_throw_type_error(napi_env env, const char* msg);
+NAPI_EXTERN napi_status napi_throw_range_error(napi_env env, const char* msg);
+NAPI_EXTERN napi_status napi_is_error(napi_env env,
+                                      napi_value value,
+                                      bool* result);
+
+// Methods to support catching exceptions
+NAPI_EXTERN napi_status napi_is_exception_pending(napi_env env, bool* result);
+NAPI_EXTERN napi_status napi_get_and_clear_last_exception(napi_env env,
+                                                          napi_value* result);
+
+// Methods to provide node::Buffer functionality with napi types
+NAPI_EXTERN napi_status napi_create_buffer(napi_env env,
+                                           size_t length,
+                                           void** data,
+                                           napi_value* result);
+NAPI_EXTERN napi_status napi_create_external_buffer(napi_env env,
+                                                    size_t length,
+                                                    void* data,
+                                                    napi_finalize finalize_cb,
+                                                    void* finalize_hint,
+                                                    napi_value* result);
+NAPI_EXTERN napi_status napi_create_buffer_copy(napi_env env,
+                                                size_t length,
+                                                const void* data,
+                                                void** result_data,
+                                                napi_value* result);
+NAPI_EXTERN napi_status napi_is_buffer(napi_env env,
+                                       napi_value value,
+                                       bool* result);
+NAPI_EXTERN napi_status napi_get_buffer_info(napi_env env,
+                                             napi_value value,
+                                             void** data,
+                                             size_t* length);
+
+// Methods to work with array buffers and typed arrays
+NAPI_EXTERN napi_status napi_is_arraybuffer(napi_env env,
+                                            napi_value value,
+                                            bool* result);
+NAPI_EXTERN napi_status napi_create_arraybuffer(napi_env env,
+                                                size_t byte_length,
+                                                void** data,
+                                                napi_value* result);
+NAPI_EXTERN napi_status
+napi_create_external_arraybuffer(napi_env env,
+                                 void* external_data,
+                                 size_t byte_length,
+                                 napi_finalize finalize_cb,
+                                 void* finalize_hint,
+                                 napi_value* result);
+NAPI_EXTERN napi_status napi_get_arraybuffer_info(napi_env env,
+                                                  napi_value arraybuffer,
+                                                  void** data,
+                                                  size_t* byte_length);
+NAPI_EXTERN napi_status napi_is_typedarray(napi_env env,
+                                           napi_value value,
+                                           bool* result);
+NAPI_EXTERN napi_status napi_create_typedarray(napi_env env,
+                                               napi_typedarray_type type,
+                                               size_t length,
+                                               napi_value arraybuffer,
+                                               size_t byte_offset,
+                                               napi_value* result);
+NAPI_EXTERN napi_status napi_get_typedarray_info(napi_env env,
+                                                 napi_value typedarray,
+                                                 napi_typedarray_type* type,
+                                                 size_t* length,
+                                                 void** data,
+                                                 napi_value* arraybuffer,
+                                                 size_t* byte_offset);
+EXTERN_C_END
+
+#endif  // SRC_NODE_API_H__
diff --git a/src/node_api_backport.h b/src/node_api_backport.h
new file mode 100644
index 00000000000000..da607735a36b74
--- /dev/null
+++ b/src/node_api_backport.h
@@ -0,0 +1,10 @@
+#ifndef SRC_NODE_API_BACKPORT_H_
+#define SRC_NODE_API_BACKPORT_H_
+
+// This file contains stubs for symbols and other features (such as async hooks)
+// which have appeared in later versions of Node.js, and which are required for
+// N-API.
+
+#define ToChecked FromJust
+
+#endif  // SRC_NODE_API_BACKPORT_H_
diff --git a/src/node_api_types.h b/src/node_api_types.h
new file mode 100644
index 00000000000000..7cb242368a367e
--- /dev/null
+++ b/src/node_api_types.h
@@ -0,0 +1,95 @@
+#ifndef SRC_NODE_API_TYPES_H_
+#define SRC_NODE_API_TYPES_H_
+
+#include <stddef.h>
+#include <stdint.h>
+
+#if !defined __cplusplus || (defined(_MSC_VER) && _MSC_VER < 1900)
+    typedef uint16_t char16_t;
+#endif
+
+// JSVM API types are all opaque pointers for ABI stability
+// typedef undefined structs instead of void* for compile time type safety
+typedef struct napi_env__ *napi_env;
+typedef struct napi_value__ *napi_value;
+typedef struct napi_ref__ *napi_ref;
+typedef struct napi_handle_scope__ *napi_handle_scope;
+typedef struct napi_escapable_handle_scope__ *napi_escapable_handle_scope;
+typedef struct napi_callback_info__ *napi_callback_info;
+
+typedef void (*napi_callback)(napi_env env,
+                              napi_callback_info info);
+typedef void (*napi_finalize)(napi_env env,
+                              void* finalize_data,
+                              void* finalize_hint);
+
+typedef enum {
+  napi_default = 0,
+  napi_read_only = 1 << 0,
+  napi_dont_enum = 1 << 1,
+  napi_dont_delete = 1 << 2,
+
+  // Used with napi_define_class to distinguish static properties
+  // from instance properties. Ignored by napi_define_properties.
+  napi_static_property = 1 << 10,
+} napi_property_attributes;
+
+typedef struct {
+  const char* utf8name;
+
+  napi_callback method;
+  napi_callback getter;
+  napi_callback setter;
+  napi_value value;
+
+  napi_property_attributes attributes;
+  void* data;
+} napi_property_descriptor;
+
+typedef enum {
+  // ES6 types (corresponds to typeof)
+  napi_undefined,
+  napi_null,
+  napi_boolean,
+  napi_number,
+  napi_string,
+  napi_symbol,
+  napi_object,
+  napi_function,
+  napi_external,
+} napi_valuetype;
+
+typedef enum {
+  napi_int8_array,
+  napi_uint8_array,
+  napi_uint8_clamped_array,
+  napi_int16_array,
+  napi_uint16_array,
+  napi_int32_array,
+  napi_uint32_array,
+  napi_float32_array,
+  napi_float64_array,
+} napi_typedarray_type;
+
+typedef enum {
+  napi_ok,
+  napi_invalid_arg,
+  napi_object_expected,
+  napi_string_expected,
+  napi_function_expected,
+  napi_number_expected,
+  napi_boolean_expected,
+  napi_array_expected,
+  napi_generic_failure,
+  napi_pending_exception,
+  napi_status_last
+} napi_status;
+
+typedef struct {
+  const char* error_message;
+  void* engine_reserved;
+  uint32_t engine_error_code;
+  napi_status error_code;
+} napi_extended_error_info;
+
+#endif  // SRC_NODE_API_TYPES_H_
diff --git a/test/addons-napi/.gitignore b/test/addons-napi/.gitignore
new file mode 100644
index 00000000000000..bde1cf3ab9662b
--- /dev/null
+++ b/test/addons-napi/.gitignore
@@ -0,0 +1,7 @@
+.buildstamp
+.docbuildstamp
+Makefile
+*.Makefile
+*.mk
+gyp-mac-tool
+/*/build
diff --git a/test/addons-napi/1_hello_world/binding.c b/test/addons-napi/1_hello_world/binding.c
new file mode 100644
index 00000000000000..882508b9548926
--- /dev/null
+++ b/test/addons-napi/1_hello_world/binding.c
@@ -0,0 +1,22 @@
+#include <node_api.h>
+
+void Method(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value world;
+  status = napi_create_string_utf8(env, "world", -1, &world);
+  if (status != napi_ok) return;
+  status = napi_set_return_value(env, info, world);
+  if (status != napi_ok) return;
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+  napi_property_descriptor desc = DECLARE_NAPI_METHOD("hello", Method);
+  status = napi_define_properties(env, exports, 1, &desc);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/1_hello_world/binding.gyp b/test/addons-napi/1_hello_world/binding.gyp
new file mode 100644
index 00000000000000..62381d5e54f22b
--- /dev/null
+++ b/test/addons-napi/1_hello_world/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "binding",
+      "sources": [ "binding.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/1_hello_world/test.js b/test/addons-napi/1_hello_world/test.js
new file mode 100644
index 00000000000000..c975c48a733f5c
--- /dev/null
+++ b/test/addons-napi/1_hello_world/test.js
@@ -0,0 +1,6 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const addon = require(`./build/${common.buildType}/binding`);
+
+assert.strictEqual(addon.hello(), 'world');
diff --git a/test/addons-napi/2_function_arguments/binding.c b/test/addons-napi/2_function_arguments/binding.c
new file mode 100644
index 00000000000000..bdc25a235c3ce5
--- /dev/null
+++ b/test/addons-napi/2_function_arguments/binding.c
@@ -0,0 +1,58 @@
+#include <node_api.h>
+
+void Add(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc < 2) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value args[2];
+  status = napi_get_cb_args(env, info, args, 2);
+  if (status != napi_ok) return;
+
+  napi_valuetype valuetype0;
+  status = napi_typeof(env, args[0], &valuetype0);
+  if (status != napi_ok) return;
+
+  napi_valuetype valuetype1;
+  status = napi_typeof(env, args[1], &valuetype1);
+  if (status != napi_ok) return;
+
+  if (valuetype0 != napi_number || valuetype1 != napi_number) {
+    napi_throw_type_error(env, "Wrong arguments");
+    return;
+  }
+
+  double value0;
+  status = napi_get_value_double(env, args[0], &value0);
+  if (status != napi_ok) return;
+
+  double value1;
+  status = napi_get_value_double(env, args[1], &value1);
+  if (status != napi_ok) return;
+
+  napi_value sum;
+  status = napi_create_number(env, value0 + value1, &sum);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, sum);
+  if (status != napi_ok) return;
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+  napi_property_descriptor addDescriptor = DECLARE_NAPI_METHOD("add", Add);
+  status = napi_define_properties(env, exports, 1, &addDescriptor);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/2_function_arguments/binding.gyp b/test/addons-napi/2_function_arguments/binding.gyp
new file mode 100644
index 00000000000000..62381d5e54f22b
--- /dev/null
+++ b/test/addons-napi/2_function_arguments/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "binding",
+      "sources": [ "binding.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/2_function_arguments/test.js b/test/addons-napi/2_function_arguments/test.js
new file mode 100644
index 00000000000000..e70f76b718bd10
--- /dev/null
+++ b/test/addons-napi/2_function_arguments/test.js
@@ -0,0 +1,6 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const addon = require(`./build/${common.buildType}/binding`);
+
+assert.strictEqual(addon.add(3, 5), 8);
diff --git a/test/addons-napi/3_callbacks/binding.c b/test/addons-napi/3_callbacks/binding.c
new file mode 100644
index 00000000000000..10e7318bcecb40
--- /dev/null
+++ b/test/addons-napi/3_callbacks/binding.c
@@ -0,0 +1,51 @@
+#include <node_api.h>
+
+#define NAPI_CALL(env, theCall)                                                \
+  if ((theCall) != napi_ok) {                                                  \
+    const napi_extended_error_info* error;                                     \
+    napi_get_last_error_info((env), &error);                                   \
+    const char* errorMessage = error->error_message;                           \
+    errorMessage = errorMessage ? errorMessage : "empty error message";        \
+    napi_throw_error((env), errorMessage);                                     \
+    return;                                                                    \
+  }
+
+void RunCallback(napi_env env, napi_callback_info info) {
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_args(env, info, args, 1));
+
+  napi_value cb = args[0];
+
+  napi_value argv[1];
+  NAPI_CALL(env, napi_create_string_utf8(env, "hello world", -1, argv));
+
+  napi_value global;
+  NAPI_CALL(env, napi_get_global(env, &global));
+
+  NAPI_CALL(env, napi_call_function(env, global, cb, 1, argv, NULL));
+}
+
+void RunCallbackWithRecv(napi_env env, napi_callback_info info) {
+  napi_value args[2];
+  NAPI_CALL(env, napi_get_cb_args(env, info, args, 2));
+
+  napi_value cb = args[0];
+  napi_value recv = args[1];
+
+  NAPI_CALL(env, napi_call_function(env, recv, cb, 0, NULL, NULL));
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+  napi_property_descriptor desc[2] = {
+      DECLARE_NAPI_METHOD("RunCallback", RunCallback),
+      DECLARE_NAPI_METHOD("RunCallbackWithRecv", RunCallbackWithRecv),
+  };
+  status = napi_define_properties(env, exports, 2, desc);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/3_callbacks/binding.gyp b/test/addons-napi/3_callbacks/binding.gyp
new file mode 100644
index 00000000000000..62381d5e54f22b
--- /dev/null
+++ b/test/addons-napi/3_callbacks/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "binding",
+      "sources": [ "binding.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/3_callbacks/test.js b/test/addons-napi/3_callbacks/test.js
new file mode 100644
index 00000000000000..25e070d9744529
--- /dev/null
+++ b/test/addons-napi/3_callbacks/test.js
@@ -0,0 +1,22 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const addon = require(`./build/${common.buildType}/binding`);
+
+addon.RunCallback(function(msg) {
+  assert.strictEqual(msg, 'hello world');
+});
+
+function testRecv(desiredRecv) {
+  addon.RunCallbackWithRecv(function() {
+    assert.strictEqual(this, desiredRecv);
+  }, desiredRecv);
+}
+
+testRecv(undefined);
+testRecv(null);
+testRecv(5);
+testRecv(true);
+testRecv('Hello');
+testRecv([]);
+testRecv({});
diff --git a/test/addons-napi/4_object_factory/binding.c b/test/addons-napi/4_object_factory/binding.c
new file mode 100644
index 00000000000000..0d9902259fe220
--- /dev/null
+++ b/test/addons-napi/4_object_factory/binding.c
@@ -0,0 +1,31 @@
+#include <node_api.h>
+
+void CreateObject(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value args[1];
+  status = napi_get_cb_args(env, info, args, 1);
+  if (status != napi_ok) return;
+
+  napi_value obj;
+  status = napi_create_object(env, &obj);
+  if (status != napi_ok) return;
+
+  status = napi_set_named_property(env, obj, "msg", args[0]);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, obj);
+  if (status != napi_ok) return;
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+  napi_property_descriptor desc = DECLARE_NAPI_METHOD("exports", CreateObject);
+  status = napi_define_properties(env, module, 1, &desc);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/4_object_factory/binding.gyp b/test/addons-napi/4_object_factory/binding.gyp
new file mode 100644
index 00000000000000..62381d5e54f22b
--- /dev/null
+++ b/test/addons-napi/4_object_factory/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "binding",
+      "sources": [ "binding.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/4_object_factory/test.js b/test/addons-napi/4_object_factory/test.js
new file mode 100644
index 00000000000000..15313c1547f24b
--- /dev/null
+++ b/test/addons-napi/4_object_factory/test.js
@@ -0,0 +1,8 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const addon = require(`./build/${common.buildType}/binding`);
+
+const obj1 = addon('hello');
+const obj2 = addon('world');
+assert.strictEqual(`${obj1.msg} ${obj2.msg}`, 'hello world');
diff --git a/test/addons-napi/5_function_factory/binding.c b/test/addons-napi/5_function_factory/binding.c
new file mode 100644
index 00000000000000..867a527ee97c64
--- /dev/null
+++ b/test/addons-napi/5_function_factory/binding.c
@@ -0,0 +1,36 @@
+#include <node_api.h>
+
+void MyFunction(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value str;
+  status = napi_create_string_utf8(env, "hello world", -1, &str);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, str);
+  if (status != napi_ok) return;
+}
+
+void CreateFunction(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value fn;
+  status = napi_create_function(env, "theFunction", MyFunction, NULL, &fn);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, fn);
+  if (status != napi_ok) return;
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+  napi_property_descriptor desc =
+      DECLARE_NAPI_METHOD("exports", CreateFunction);
+  status = napi_define_properties(env, module, 1, &desc);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/5_function_factory/binding.gyp b/test/addons-napi/5_function_factory/binding.gyp
new file mode 100644
index 00000000000000..62381d5e54f22b
--- /dev/null
+++ b/test/addons-napi/5_function_factory/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "binding",
+      "sources": [ "binding.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/5_function_factory/test.js b/test/addons-napi/5_function_factory/test.js
new file mode 100644
index 00000000000000..7521824e1e000a
--- /dev/null
+++ b/test/addons-napi/5_function_factory/test.js
@@ -0,0 +1,7 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const addon = require(`./build/${common.buildType}/binding`);
+
+const fn = addon();
+assert.strictEqual(fn(), 'hello world'); // 'hello world'
diff --git a/test/addons-napi/6_object_wrap/binding.cc b/test/addons-napi/6_object_wrap/binding.cc
new file mode 100644
index 00000000000000..99d8339bd09ef3
--- /dev/null
+++ b/test/addons-napi/6_object_wrap/binding.cc
@@ -0,0 +1,7 @@
+#include "myobject.h"
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  MyObject::Init(env, exports);
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/6_object_wrap/binding.gyp b/test/addons-napi/6_object_wrap/binding.gyp
new file mode 100644
index 00000000000000..d8f91601e9c588
--- /dev/null
+++ b/test/addons-napi/6_object_wrap/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "binding",
+      "sources": [ "binding.cc", "myobject.cc" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/6_object_wrap/myobject.cc b/test/addons-napi/6_object_wrap/myobject.cc
new file mode 100644
index 00000000000000..67521ae3132fc6
--- /dev/null
+++ b/test/addons-napi/6_object_wrap/myobject.cc
@@ -0,0 +1,201 @@
+#include "myobject.h"
+
+napi_ref MyObject::constructor;
+
+MyObject::MyObject(double value)
+    : value_(value), env_(nullptr), wrapper_(nullptr) {}
+
+MyObject::~MyObject() { napi_delete_reference(env_, wrapper_); }
+
+void MyObject::Destructor(
+  napi_env env, void* nativeObject, void* /*finalize_hint*/) {
+  MyObject* obj = static_cast<MyObject*>(nativeObject);
+  delete obj;
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void MyObject::Init(napi_env env, napi_value exports) {
+  napi_status status;
+  napi_property_descriptor properties[] = {
+      { "value", nullptr, GetValue, SetValue, 0, napi_default, 0 },
+      DECLARE_NAPI_METHOD("plusOne", PlusOne),
+      DECLARE_NAPI_METHOD("multiply", Multiply),
+  };
+
+  napi_value cons;
+  status =
+      napi_define_class(env, "MyObject", New, nullptr, 3, properties, &cons);
+  if (status != napi_ok) return;
+
+  status = napi_create_reference(env, cons, 1, &constructor);
+  if (status != napi_ok) return;
+
+  status = napi_set_named_property(env, exports, "MyObject", cons);
+  if (status != napi_ok) return;
+}
+
+void MyObject::New(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  bool is_constructor;
+  status = napi_is_construct_call(env, info, &is_constructor);
+  if (status != napi_ok) return;
+
+  if (is_constructor) {
+    // Invoked as constructor: `new MyObject(...)`
+    napi_value args[1];
+    status = napi_get_cb_args(env, info, args, 1);
+    if (status != napi_ok) return;
+
+    double value = 0;
+
+    napi_valuetype valuetype;
+    status = napi_typeof(env, args[0], &valuetype);
+    if (status != napi_ok) return;
+
+    if (valuetype != napi_undefined) {
+      status = napi_get_value_double(env, args[0], &value);
+      if (status != napi_ok) return;
+    }
+
+    MyObject* obj = new MyObject(value);
+
+    napi_value jsthis;
+    status = napi_get_cb_this(env, info, &jsthis);
+    if (status != napi_ok) return;
+
+    obj->env_ = env;
+    status = napi_wrap(env,
+                       jsthis,
+                       obj,
+                       MyObject::Destructor,
+                       nullptr,  // finalize_hint
+                       &obj->wrapper_);
+    if (status != napi_ok) return;
+
+    status = napi_set_return_value(env, info, jsthis);
+    if (status != napi_ok) return;
+  } else {
+    // Invoked as plain function `MyObject(...)`, turn into construct call.
+    napi_value args[1];
+    status = napi_get_cb_args(env, info, args, 1);
+    if (status != napi_ok) return;
+
+    const int argc = 1;
+    napi_value argv[argc] = {args[0]};
+
+    napi_value cons;
+    status = napi_get_reference_value(env, constructor, &cons);
+    if (status != napi_ok) return;
+
+    napi_value instance;
+    status = napi_new_instance(env, cons, argc, argv, &instance);
+    if (status != napi_ok) return;
+
+    status = napi_set_return_value(env, info, instance);
+    if (status != napi_ok) return;
+  }
+}
+
+void MyObject::GetValue(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value jsthis;
+  status = napi_get_cb_this(env, info, &jsthis);
+  if (status != napi_ok) return;
+
+  MyObject* obj;
+  status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
+  if (status != napi_ok) return;
+
+  napi_value num;
+  status = napi_create_number(env, obj->value_, &num);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, num);
+  if (status != napi_ok) return;
+}
+
+void MyObject::SetValue(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value value;
+  status = napi_get_cb_args(env, info, &value, 1);
+  if (status != napi_ok) return;
+
+  napi_value jsthis;
+  status = napi_get_cb_this(env, info, &jsthis);
+  if (status != napi_ok) return;
+
+  MyObject* obj;
+  status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
+  if (status != napi_ok) return;
+
+  status = napi_get_value_double(env, value, &obj->value_);
+  if (status != napi_ok) return;
+}
+
+void MyObject::PlusOne(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value jsthis;
+  status = napi_get_cb_this(env, info, &jsthis);
+  if (status != napi_ok) return;
+
+  MyObject* obj;
+  status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
+  if (status != napi_ok) return;
+
+  obj->value_ += 1;
+
+  napi_value num;
+  status = napi_create_number(env, obj->value_, &num);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, num);
+  if (status != napi_ok) return;
+}
+
+void MyObject::Multiply(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value args[1];
+  status = napi_get_cb_args(env, info, args, 1);
+  if (status != napi_ok) return;
+
+  napi_valuetype valuetype;
+  status = napi_typeof(env, args[0], &valuetype);
+  if (status != napi_ok) return;
+
+  double multiple = 1;
+  if (valuetype != napi_undefined) {
+    status = napi_get_value_double(env, args[0], &multiple);
+    if (status != napi_ok) return;
+  }
+
+  napi_value jsthis;
+  status = napi_get_cb_this(env, info, &jsthis);
+  if (status != napi_ok) return;
+
+  MyObject* obj;
+  status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
+  if (status != napi_ok) return;
+
+  napi_value cons;
+  status = napi_get_reference_value(env, constructor, &cons);
+  if (status != napi_ok) return;
+
+  const int kArgCount = 1;
+  napi_value argv[kArgCount];
+  status = napi_create_number(env, obj->value_ * multiple, argv);
+  if (status != napi_ok) return;
+
+  napi_value instance;
+  status = napi_new_instance(env, cons, kArgCount, argv, &instance);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, instance);
+  if (status != napi_ok) return;
+}
diff --git a/test/addons-napi/6_object_wrap/myobject.h b/test/addons-napi/6_object_wrap/myobject.h
new file mode 100644
index 00000000000000..2c8f47753769f5
--- /dev/null
+++ b/test/addons-napi/6_object_wrap/myobject.h
@@ -0,0 +1,26 @@
+#ifndef TEST_ADDONS_NAPI_6_OBJECT_WRAP_MYOBJECT_H_
+#define TEST_ADDONS_NAPI_6_OBJECT_WRAP_MYOBJECT_H_
+
+#include <node_api.h>
+
+class MyObject {
+ public:
+  static void Init(napi_env env, napi_value exports);
+  static void Destructor(napi_env env, void* nativeObject, void* finalize_hint);
+
+ private:
+  explicit MyObject(double value_ = 0);
+  ~MyObject();
+
+  static void New(napi_env env, napi_callback_info info);
+  static void GetValue(napi_env env, napi_callback_info info);
+  static void SetValue(napi_env env, napi_callback_info info);
+  static void PlusOne(napi_env env, napi_callback_info info);
+  static void Multiply(napi_env env, napi_callback_info info);
+  static napi_ref constructor;
+  double value_;
+  napi_env env_;
+  napi_ref wrapper_;
+};
+
+#endif  // TEST_ADDONS_NAPI_6_OBJECT_WRAP_MYOBJECT_H_
diff --git a/test/addons-napi/6_object_wrap/test.js b/test/addons-napi/6_object_wrap/test.js
new file mode 100644
index 00000000000000..4d89da6a4350bd
--- /dev/null
+++ b/test/addons-napi/6_object_wrap/test.js
@@ -0,0 +1,19 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const addon = require(`./build/${common.buildType}/binding`);
+
+const obj = new addon.MyObject(9);
+assert.strictEqual(obj.value, 9);
+obj.value = 10;
+assert.strictEqual(obj.value, 10);
+assert.strictEqual(obj.plusOne(), 11);
+assert.strictEqual(obj.plusOne(), 12);
+assert.strictEqual(obj.plusOne(), 13);
+
+assert.strictEqual(obj.multiply().value, 13);
+assert.strictEqual(obj.multiply(10).value, 130);
+
+const newobj = obj.multiply(-1);
+assert.strictEqual(newobj.value, -13);
+assert.notStrictEqual(obj, newobj);
diff --git a/test/addons-napi/7_factory_wrap/binding.cc b/test/addons-napi/7_factory_wrap/binding.cc
new file mode 100644
index 00000000000000..0aede8cbb8c201
--- /dev/null
+++ b/test/addons-napi/7_factory_wrap/binding.cc
@@ -0,0 +1,32 @@
+#include "myobject.h"
+
+void CreateObject(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value args[1];
+  status = napi_get_cb_args(env, info, args, 1);
+  if (status != napi_ok) return;
+
+  napi_value instance;
+  status = MyObject::NewInstance(env, args[0], &instance);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, instance);
+  if (status != napi_ok) return;
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+
+  status = MyObject::Init(env);
+  if (status != napi_ok) return;
+
+  napi_property_descriptor desc = DECLARE_NAPI_METHOD("exports", CreateObject);
+  status = napi_define_properties(env, module, 1, &desc);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/7_factory_wrap/binding.gyp b/test/addons-napi/7_factory_wrap/binding.gyp
new file mode 100644
index 00000000000000..d8f91601e9c588
--- /dev/null
+++ b/test/addons-napi/7_factory_wrap/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "binding",
+      "sources": [ "binding.cc", "myobject.cc" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/7_factory_wrap/myobject.cc b/test/addons-napi/7_factory_wrap/myobject.cc
new file mode 100644
index 00000000000000..a3fbf6f9ecf1d5
--- /dev/null
+++ b/test/addons-napi/7_factory_wrap/myobject.cc
@@ -0,0 +1,110 @@
+#include "myobject.h"
+
+MyObject::MyObject() : env_(nullptr), wrapper_(nullptr) {}
+
+MyObject::~MyObject() { napi_delete_reference(env_, wrapper_); }
+
+void MyObject::Destructor(napi_env env,
+                          void* nativeObject,
+                          void* /*finalize_hint*/) {
+  MyObject* obj = static_cast<MyObject*>(nativeObject);
+  delete obj;
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+napi_ref MyObject::constructor;
+
+napi_status MyObject::Init(napi_env env) {
+  napi_status status;
+  napi_property_descriptor properties[] = {
+      DECLARE_NAPI_METHOD("plusOne", PlusOne),
+  };
+
+  napi_value cons;
+  status =
+      napi_define_class(env, "MyObject", New, nullptr, 1, properties, &cons);
+  if (status != napi_ok) return status;
+
+  status = napi_create_reference(env, cons, 1, &constructor);
+  if (status != napi_ok) return status;
+
+  return napi_ok;
+}
+
+void MyObject::New(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value args[1];
+  status = napi_get_cb_args(env, info, args, 1);
+  if (status != napi_ok) return;
+
+  napi_valuetype valuetype;
+  status = napi_typeof(env, args[0], &valuetype);
+  if (status != napi_ok) return;
+
+  MyObject* obj = new MyObject();
+
+  if (valuetype == napi_undefined) {
+    obj->counter_ = 0;
+  } else {
+    status = napi_get_value_double(env, args[0], &obj->counter_);
+    if (status != napi_ok) return;
+  }
+
+  napi_value jsthis;
+  status = napi_get_cb_this(env, info, &jsthis);
+  if (status != napi_ok) return;
+
+  obj->env_ = env;
+  status = napi_wrap(env,
+                     jsthis,
+                     obj,
+                     MyObject::Destructor,
+                     nullptr, /* finalize_hint */
+                     &obj->wrapper_);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, jsthis);
+  if (status != napi_ok) return;
+}
+
+napi_status MyObject::NewInstance(napi_env env,
+                                  napi_value arg,
+                                  napi_value* instance) {
+  napi_status status;
+
+  const int argc = 1;
+  napi_value argv[argc] = {arg};
+
+  napi_value cons;
+  status = napi_get_reference_value(env, constructor, &cons);
+  if (status != napi_ok) return status;
+
+  status = napi_new_instance(env, cons, argc, argv, instance);
+  if (status != napi_ok) return status;
+
+  return napi_ok;
+}
+
+void MyObject::PlusOne(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value jsthis;
+  status = napi_get_cb_this(env, info, &jsthis);
+  if (status != napi_ok) return;
+
+  MyObject* obj;
+  status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
+  if (status != napi_ok) return;
+
+  obj->counter_ += 1;
+
+  napi_value num;
+  status = napi_create_number(env, obj->counter_, &num);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, num);
+  if (status != napi_ok) return;
+}
diff --git a/test/addons-napi/7_factory_wrap/myobject.h b/test/addons-napi/7_factory_wrap/myobject.h
new file mode 100644
index 00000000000000..323079951e6633
--- /dev/null
+++ b/test/addons-napi/7_factory_wrap/myobject.h
@@ -0,0 +1,26 @@
+#ifndef TEST_ADDONS_NAPI_7_FACTORY_WRAP_MYOBJECT_H_
+#define TEST_ADDONS_NAPI_7_FACTORY_WRAP_MYOBJECT_H_
+
+#include <node_api.h>
+
+class MyObject {
+ public:
+  static napi_status Init(napi_env env);
+  static void Destructor(napi_env env, void* nativeObject, void* finalize_hint);
+  static napi_status NewInstance(napi_env env,
+                                 napi_value arg,
+                                 napi_value* instance);
+
+ private:
+  MyObject();
+  ~MyObject();
+
+  static napi_ref constructor;
+  static void New(napi_env env, napi_callback_info info);
+  static void PlusOne(napi_env env, napi_callback_info info);
+  double counter_;
+  napi_env env_;
+  napi_ref wrapper_;
+};
+
+#endif  // TEST_ADDONS_NAPI_7_FACTORY_WRAP_MYOBJECT_H_
diff --git a/test/addons-napi/7_factory_wrap/test.js b/test/addons-napi/7_factory_wrap/test.js
new file mode 100644
index 00000000000000..20108e14b629bc
--- /dev/null
+++ b/test/addons-napi/7_factory_wrap/test.js
@@ -0,0 +1,14 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const createObject = require(`./build/${common.buildType}/binding`);
+
+const obj = createObject(10);
+assert.strictEqual(obj.plusOne(), 11);
+assert.strictEqual(obj.plusOne(), 12);
+assert.strictEqual(obj.plusOne(), 13);
+
+const obj2 = createObject(20);
+assert.strictEqual(obj2.plusOne(), 21);
+assert.strictEqual(obj2.plusOne(), 22);
+assert.strictEqual(obj2.plusOne(), 23);
diff --git a/test/addons-napi/8_passing_wrapped/binding.cc b/test/addons-napi/8_passing_wrapped/binding.cc
new file mode 100644
index 00000000000000..d6a4eafd883a45
--- /dev/null
+++ b/test/addons-napi/8_passing_wrapped/binding.cc
@@ -0,0 +1,57 @@
+#include "myobject.h"
+
+void CreateObject(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value args[1];
+  status = napi_get_cb_args(env, info, args, 1);
+  if (status != napi_ok) return;
+
+  napi_value instance;
+  status = MyObject::NewInstance(env, args[0], &instance);
+
+  status = napi_set_return_value(env, info, instance);
+  if (status != napi_ok) return;
+}
+
+void Add(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value args[2];
+  status = napi_get_cb_args(env, info, args, 2);
+  if (status != napi_ok) return;
+
+  MyObject* obj1;
+  status = napi_unwrap(env, args[0], reinterpret_cast<void**>(&obj1));
+  if (status != napi_ok) return;
+
+  MyObject* obj2;
+  status = napi_unwrap(env, args[1], reinterpret_cast<void**>(&obj2));
+  if (status != napi_ok) return;
+
+  napi_value sum;
+  status = napi_create_number(env, obj1->Val() + obj2->Val(), &sum);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, sum);
+  if (status != napi_ok) return;
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+
+  MyObject::Init(env);
+
+  napi_property_descriptor desc[] = {
+      DECLARE_NAPI_METHOD("createObject", CreateObject),
+      DECLARE_NAPI_METHOD("add", Add),
+  };
+  status =
+      napi_define_properties(env, exports, sizeof(desc) / sizeof(*desc), desc);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/8_passing_wrapped/binding.gyp b/test/addons-napi/8_passing_wrapped/binding.gyp
new file mode 100644
index 00000000000000..d8f91601e9c588
--- /dev/null
+++ b/test/addons-napi/8_passing_wrapped/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "binding",
+      "sources": [ "binding.cc", "myobject.cc" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/8_passing_wrapped/myobject.cc b/test/addons-napi/8_passing_wrapped/myobject.cc
new file mode 100644
index 00000000000000..8bca17a3be39b8
--- /dev/null
+++ b/test/addons-napi/8_passing_wrapped/myobject.cc
@@ -0,0 +1,81 @@
+#include "myobject.h"
+
+MyObject::MyObject() : env_(nullptr), wrapper_(nullptr) {}
+
+MyObject::~MyObject() { napi_delete_reference(env_, wrapper_); }
+
+void MyObject::Destructor(
+  napi_env env, void* nativeObject, void* /*finalize_hint*/) {
+  MyObject* obj = static_cast<MyObject*>(nativeObject);
+  delete obj;
+}
+
+napi_ref MyObject::constructor;
+
+napi_status MyObject::Init(napi_env env) {
+  napi_status status;
+
+  napi_value cons;
+  status = napi_define_class(env, "MyObject", New, nullptr, 0, nullptr, &cons);
+  if (status != napi_ok) return status;
+
+  status = napi_create_reference(env, cons, 1, &constructor);
+  if (status != napi_ok) return status;
+
+  return napi_ok;
+}
+
+void MyObject::New(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value args[1];
+  status = napi_get_cb_args(env, info, args, 1);
+  if (status != napi_ok) return;
+
+  MyObject* obj = new MyObject();
+
+  napi_valuetype valuetype;
+  status = napi_typeof(env, args[0], &valuetype);
+  if (status != napi_ok) return;
+
+  if (valuetype == napi_undefined) {
+    obj->val_ = 0;
+  } else {
+    status = napi_get_value_double(env, args[0], &obj->val_);
+    if (status != napi_ok) return;
+  }
+
+  napi_value jsthis;
+  status = napi_get_cb_this(env, info, &jsthis);
+  if (status != napi_ok) return;
+
+  obj->env_ = env;
+  status = napi_wrap(env,
+                     jsthis,
+                     obj,
+                     MyObject::Destructor,
+                     nullptr,  // finalize_hint
+                     &obj->wrapper_);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, jsthis);
+  if (status != napi_ok) return;
+}
+
+napi_status MyObject::NewInstance(napi_env env,
+                                  napi_value arg,
+                                  napi_value* instance) {
+  napi_status status;
+
+  const int argc = 1;
+  napi_value argv[argc] = {arg};
+
+  napi_value cons;
+  status = napi_get_reference_value(env, constructor, &cons);
+  if (status != napi_ok) return status;
+
+  status = napi_new_instance(env, cons, argc, argv, instance);
+  if (status != napi_ok) return status;
+
+  return napi_ok;
+}
diff --git a/test/addons-napi/8_passing_wrapped/myobject.h b/test/addons-napi/8_passing_wrapped/myobject.h
new file mode 100644
index 00000000000000..773c86e04bba81
--- /dev/null
+++ b/test/addons-napi/8_passing_wrapped/myobject.h
@@ -0,0 +1,26 @@
+#ifndef TEST_ADDONS_NAPI_8_PASSING_WRAPPED_MYOBJECT_H_
+#define TEST_ADDONS_NAPI_8_PASSING_WRAPPED_MYOBJECT_H_
+
+#include <node_api.h>
+
+class MyObject {
+ public:
+  static napi_status Init(napi_env env);
+  static void Destructor(napi_env env, void* nativeObject, void* finalize_hint);
+  static napi_status NewInstance(napi_env env,
+                                 napi_value arg,
+                                 napi_value* instance);
+  double Val() const { return val_; }
+
+ private:
+  MyObject();
+  ~MyObject();
+
+  static napi_ref constructor;
+  static void New(napi_env env, napi_callback_info info);
+  double val_;
+  napi_env env_;
+  napi_ref wrapper_;
+};
+
+#endif  // TEST_ADDONS_NAPI_8_PASSING_WRAPPED_MYOBJECT_H_
diff --git a/test/addons-napi/8_passing_wrapped/test.js b/test/addons-napi/8_passing_wrapped/test.js
new file mode 100644
index 00000000000000..3d24fa5d9fdaa7
--- /dev/null
+++ b/test/addons-napi/8_passing_wrapped/test.js
@@ -0,0 +1,9 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const addon = require(`./build/${common.buildType}/binding`);
+
+const obj1 = addon.createObject(10);
+const obj2 = addon.createObject(20);
+const result = addon.add(obj1, obj2);
+assert.strictEqual(result, 30);
diff --git a/test/addons-napi/test_array/binding.gyp b/test/addons-napi/test_array/binding.gyp
new file mode 100644
index 00000000000000..44920de0986fdc
--- /dev/null
+++ b/test/addons-napi/test_array/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_array",
+      "sources": [ "test_array.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_array/test.js b/test/addons-napi/test_array/test.js
new file mode 100644
index 00000000000000..c2759b007249e9
--- /dev/null
+++ b/test/addons-napi/test_array/test.js
@@ -0,0 +1,37 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+
+// Testing api calls for arrays
+const test_array = require(`./build/${common.buildType}/test_array`);
+
+const array = [
+  1,
+  9,
+  48,
+  13493,
+  9459324,
+  { name: 'hello' },
+  [
+    'world',
+    'node',
+    'abi'
+  ]
+];
+
+assert.strictEqual(test_array.Test(array, array.length + 1),
+                   'Index out of bound!');
+
+assert.throws(
+  () => {
+    test_array.Test(array, -2);
+  },
+  /Invalid index\. Expects a positive integer\./
+);
+
+array.forEach(function(element, index) {
+  assert.strictEqual(test_array.Test(array, index), element);
+});
+
+
+assert.deepStrictEqual(test_array.New(array), array);
diff --git a/test/addons-napi/test_array/test_array.c b/test/addons-napi/test_array/test_array.c
new file mode 100644
index 00000000000000..e5c4be4e8f547d
--- /dev/null
+++ b/test/addons-napi/test_array/test_array.c
@@ -0,0 +1,137 @@
+#include <node_api.h>
+#include <string.h>
+
+void Test(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc < 2) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value args[2];
+  status = napi_get_cb_args(env, info, args, 2);
+  if (status != napi_ok) return;
+
+  napi_valuetype valuetype0;
+  status = napi_typeof(env, args[0], &valuetype0);
+  if (status != napi_ok) return;
+
+  if (valuetype0 != napi_object) {
+    napi_throw_type_error(
+        env, "Wrong type of argments. Expects an array as first argument.");
+    return;
+  }
+
+  napi_valuetype valuetype1;
+  status = napi_typeof(env, args[1], &valuetype1);
+  if (status != napi_ok) return;
+
+  if (valuetype1 != napi_number) {
+    napi_throw_type_error(
+        env, "Wrong type of argments. Expects an integer as second argument.");
+    return;
+  }
+
+  napi_value array = args[0];
+  int index;
+  status = napi_get_value_int32(env, args[1], &index);
+  if (status != napi_ok) return;
+
+  bool isarray;
+  status = napi_is_array(env, array, &isarray);
+  if (status != napi_ok) return;
+
+  if (isarray) {
+    uint32_t size;
+    status = napi_get_array_length(env, array, &size);
+    if (status != napi_ok) return;
+
+    if (index >= (int)(size)) {
+      napi_value str;
+      status = napi_create_string_utf8(env, "Index out of bound!", -1, &str);
+      if (status != napi_ok) return;
+
+      status = napi_set_return_value(env, info, str);
+      if (status != napi_ok) return;
+    } else if (index < 0) {
+      napi_throw_type_error(env, "Invalid index. Expects a positive integer.");
+    } else {
+      napi_value ret;
+      status = napi_get_element(env, array, index, &ret);
+      if (status != napi_ok) return;
+
+      status = napi_set_return_value(env, info, ret);
+      if (status != napi_ok) return;
+    }
+  }
+}
+
+void New(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc < 1) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value args[1];
+  status = napi_get_cb_args(env, info, args, 1);
+  if (status != napi_ok) return;
+
+  napi_valuetype valuetype;
+  status = napi_typeof(env, args[0], &valuetype);
+  if (status != napi_ok) return;
+
+  if (valuetype != napi_object) {
+    napi_throw_type_error(
+        env, "Wrong type of argments. Expects an array as first argument.");
+    return;
+  }
+
+  napi_value ret;
+  status = napi_create_array(env, &ret);
+  if (status != napi_ok) return;
+
+  uint32_t i, length;
+  status = napi_get_array_length(env, args[0], &length);
+  if (status != napi_ok) return;
+
+  for (i = 0; i < length; i++) {
+    napi_value e;
+    status = napi_get_element(env, args[0], i, &e);
+    if (status != napi_ok) return;
+
+    status = napi_set_element(env, ret, i, e);
+    if (status != napi_ok) return;
+  }
+
+  status = napi_set_return_value(env, info, ret);
+  if (status != napi_ok) return;
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+
+  napi_property_descriptor descriptors[] = {
+      DECLARE_NAPI_METHOD("Test", Test),
+      DECLARE_NAPI_METHOD("New", New),
+  };
+
+  status = napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_buffer/binding.gyp b/test/addons-napi/test_buffer/binding.gyp
new file mode 100644
index 00000000000000..e41a3993cd7c9d
--- /dev/null
+++ b/test/addons-napi/test_buffer/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_buffer",
+      "sources": [ "test_buffer.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_buffer/test.js b/test/addons-napi/test_buffer/test.js
new file mode 100644
index 00000000000000..6fb80b02053f9f
--- /dev/null
+++ b/test/addons-napi/test_buffer/test.js
@@ -0,0 +1,25 @@
+'use strict';
+// Flags: --expose-gc
+
+const common = require('../../common');
+const binding = require(`./build/${common.buildType}/test_buffer`);
+const assert = require('assert');
+
+assert.strictEqual(binding.newBuffer().toString(), binding.theText,
+                   'buffer returned by newBuffer() has wrong contents');
+assert.strictEqual(binding.newExternalBuffer().toString(), binding.theText,
+                   'buffer returned by newExternalBuffer() has wrong contents');
+console.log('gc1');
+global.gc();
+assert.strictEqual(binding.getDeleterCallCount(), 1, 'deleter was not called');
+assert.strictEqual(binding.copyBuffer().toString(), binding.theText,
+                   'buffer returned by copyBuffer() has wrong contents');
+
+let buffer = binding.staticBuffer();
+assert.strictEqual(binding.bufferHasInstance(buffer), true,
+                   'buffer type checking fails');
+assert.strictEqual(binding.bufferInfo(buffer), true, 'buffer data is accurate');
+buffer = null;
+global.gc();
+console.log('gc2');
+assert.strictEqual(binding.getDeleterCallCount(), 2, 'deleter was not called');
diff --git a/test/addons-napi/test_buffer/test_buffer.c b/test/addons-napi/test_buffer/test_buffer.c
new file mode 100644
index 00000000000000..cfb8f44cc77930
--- /dev/null
+++ b/test/addons-napi/test_buffer/test_buffer.c
@@ -0,0 +1,160 @@
+#include <stdlib.h>
+#include <string.h>
+#include <node_api.h>
+
+#define JS_ASSERT(env, assertion, message)              \
+  if (!(assertion)) {                                   \
+    napi_throw_error(                                   \
+        (env),                                          \
+        "assertion (" #assertion ") failed: " message); \
+    return;                                             \
+  }
+
+#define NAPI_CALL(env, theCall)                                                \
+  if ((theCall) != napi_ok) {                                                  \
+    const napi_extended_error_info* error;                                     \
+    napi_get_last_error_info((env), &error);                                   \
+    const char* errorMessage = error->error_message;                           \
+    errorMessage = errorMessage ? errorMessage : "empty error message";        \
+    napi_throw_error((env), errorMessage);                                     \
+    return;                                                                    \
+  }
+
+static const char theText[] =
+    "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
+
+static int deleterCallCount = 0;
+static void deleteTheText(napi_env env, void* data, void* finalize_hint) {
+  JS_ASSERT(env, data != NULL && strcmp(data, theText) == 0, "invalid data");
+  (void)finalize_hint;
+  free(data);
+  deleterCallCount++;
+}
+
+static void noopDeleter(napi_env env, void* data, void* finalize_hint) {
+  JS_ASSERT(env, data != NULL && strcmp(data, theText) == 0, "invalid data");
+  (void)finalize_hint;
+  deleterCallCount++;
+}
+
+void newBuffer(napi_env env, napi_callback_info info) {
+  napi_value theBuffer;
+  char* theCopy;
+  const unsigned int kBufferSize = sizeof(theText);
+
+  NAPI_CALL(env,
+            napi_create_buffer(
+                env,
+                sizeof(theText),
+                (void**)(&theCopy),
+                &theBuffer));
+  JS_ASSERT(env, theCopy, "Failed to copy static text for newBuffer");
+  memcpy(theCopy, theText, kBufferSize);
+  NAPI_CALL(env, napi_set_return_value(env, info, theBuffer));
+}
+
+void newExternalBuffer(napi_env env, napi_callback_info info) {
+  napi_value theBuffer;
+  char* theCopy = strdup(theText);
+  JS_ASSERT(env, theCopy, "Failed to copy static text for newExternalBuffer");
+  NAPI_CALL(env,
+            napi_create_external_buffer(
+                env,
+                sizeof(theText),
+                theCopy,
+                deleteTheText,
+                NULL,  // finalize_hint
+                &theBuffer));
+  NAPI_CALL(env, napi_set_return_value(env, info, theBuffer));
+}
+
+void getDeleterCallCount(napi_env env, napi_callback_info info) {
+  napi_value callCount;
+  NAPI_CALL(env, napi_create_number(env, deleterCallCount, &callCount));
+  NAPI_CALL(env, napi_set_return_value(env, info, callCount));
+}
+
+void copyBuffer(napi_env env, napi_callback_info info) {
+  napi_value theBuffer;
+  NAPI_CALL(env, napi_create_buffer_copy(
+    env, sizeof(theText), theText, NULL, &theBuffer));
+  NAPI_CALL(env, napi_set_return_value(env, info, theBuffer));
+}
+
+void bufferHasInstance(napi_env env, napi_callback_info info) {
+  size_t argc;
+  NAPI_CALL(env, napi_get_cb_args_length(env, info, &argc));
+  JS_ASSERT(env, argc == 1, "Wrong number of arguments");
+  napi_value theBuffer;
+  NAPI_CALL(env, napi_get_cb_args(env, info, &theBuffer, 1));
+  bool hasInstance;
+  napi_valuetype theType;
+  NAPI_CALL(env, napi_typeof(env, theBuffer, &theType));
+  JS_ASSERT(env,
+            theType == napi_object,
+            "bufferHasInstance: instance is not an object");
+  NAPI_CALL(env, napi_is_buffer(env, theBuffer, &hasInstance));
+  JS_ASSERT(env, hasInstance, "bufferHasInstance: instance is not a buffer");
+  napi_value returnValue;
+  NAPI_CALL(env, napi_get_boolean(env, hasInstance, &returnValue));
+  NAPI_CALL(env, napi_set_return_value(env, info, returnValue));
+}
+
+void bufferInfo(napi_env env, napi_callback_info info) {
+  size_t argc;
+  NAPI_CALL(env, napi_get_cb_args_length(env, info, &argc));
+  JS_ASSERT(env, argc == 1, "Wrong number of arguments");
+  napi_value theBuffer, returnValue;
+  NAPI_CALL(env, napi_get_cb_args(env, info, &theBuffer, 1));
+  char* bufferData;
+  size_t bufferLength;
+  NAPI_CALL(env,
+            napi_get_buffer_info(
+                env,
+                theBuffer,
+                (void**)(&bufferData),
+                &bufferLength));
+  NAPI_CALL(env, napi_get_boolean(env,
+    !strcmp(bufferData, theText) && bufferLength == sizeof(theText),
+    &returnValue));
+  NAPI_CALL(env, napi_set_return_value(env, info, returnValue));
+}
+
+void staticBuffer(napi_env env, napi_callback_info info) {
+  napi_value theBuffer;
+  NAPI_CALL(
+      env,
+      napi_create_external_buffer(env,
+                                  sizeof(theText),
+                                  (void*)theText,
+                                  noopDeleter,
+                                  NULL,  // finalize_hint
+                                  &theBuffer));
+  NAPI_CALL(env, napi_set_return_value(env, info, theBuffer));
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_value theValue;
+
+  NAPI_CALL(env, napi_create_string_utf8(env,
+            theText, sizeof(theText), &theValue));
+  NAPI_CALL(env, napi_set_named_property(env, exports, "theText", theValue));
+
+  napi_property_descriptor methods[] = {
+      DECLARE_NAPI_METHOD("newBuffer", newBuffer),
+      DECLARE_NAPI_METHOD("newExternalBuffer", newExternalBuffer),
+      DECLARE_NAPI_METHOD("getDeleterCallCount", getDeleterCallCount),
+      DECLARE_NAPI_METHOD("copyBuffer", copyBuffer),
+      DECLARE_NAPI_METHOD("bufferHasInstance", bufferHasInstance),
+      DECLARE_NAPI_METHOD("bufferInfo", bufferInfo),
+      DECLARE_NAPI_METHOD("staticBuffer", staticBuffer),
+  };
+  NAPI_CALL(env,
+            napi_define_properties(
+                env, exports, sizeof(methods) / sizeof(methods[0]), methods));
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_constructor/binding.gyp b/test/addons-napi/test_constructor/binding.gyp
new file mode 100644
index 00000000000000..55140e7c379f02
--- /dev/null
+++ b/test/addons-napi/test_constructor/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_constructor",
+      "sources": [ "test_constructor.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_constructor/test.js b/test/addons-napi/test_constructor/test.js
new file mode 100644
index 00000000000000..9feae5a1360b2c
--- /dev/null
+++ b/test/addons-napi/test_constructor/test.js
@@ -0,0 +1,28 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+
+// Testing api calls for a constructor that defines properties
+const TestConstructor = require(`./build/${common.buildType}/test_constructor`);
+const test_object = new TestConstructor();
+
+assert.strictEqual(test_object.echo('hello'), 'hello');
+
+test_object.readwriteValue = 1;
+assert.strictEqual(test_object.readwriteValue, 1);
+test_object.readwriteValue = 2;
+assert.strictEqual(test_object.readwriteValue, 2);
+
+assert.throws(() => { test_object.readonlyValue = 3; });
+
+assert.ok(test_object.hiddenValue);
+
+// All properties except 'hiddenValue' should be enumerable.
+const propertyNames = [];
+for (const name in test_object) {
+  propertyNames.push(name);
+}
+assert.ok(propertyNames.indexOf('echo') >= 0);
+assert.ok(propertyNames.indexOf('readwriteValue') >= 0);
+assert.ok(propertyNames.indexOf('readonlyValue') >= 0);
+assert.ok(propertyNames.indexOf('hiddenValue') < 0);
diff --git a/test/addons-napi/test_constructor/test_constructor.c b/test/addons-napi/test_constructor/test_constructor.c
new file mode 100644
index 00000000000000..5a45da30739d6d
--- /dev/null
+++ b/test/addons-napi/test_constructor/test_constructor.c
@@ -0,0 +1,104 @@
+#include <node_api.h>
+
+static double value_ = 1;
+napi_ref constructor_;
+
+void GetValue(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc != 0) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value number;
+  status = napi_create_number(env, value_, &number);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, number);
+  if (status != napi_ok) return;
+}
+
+void SetValue(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc != 1) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value arg;
+  status = napi_get_cb_args(env, info, &arg, 1);
+  if (status != napi_ok) return;
+
+  status = napi_get_value_double(env, arg, &value_);
+  if (status != napi_ok) return;
+}
+
+void Echo(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc != 1) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value arg;
+  status = napi_get_cb_args(env, info, &arg, 1);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, arg);
+  if (status != napi_ok) return;
+}
+
+void New(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value jsthis;
+  status = napi_get_cb_this(env, info, &jsthis);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, jsthis);
+  if (status != napi_ok) return;
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+
+  napi_value number;
+  status = napi_create_number(env, value_, &number);
+  if (status != napi_ok) return;
+
+  napi_property_descriptor properties[] = {
+      { "echo", Echo, 0, 0, 0, napi_default, 0 },
+      { "accessorValue", 0, GetValue, SetValue, 0, napi_default, 0},
+      { "readwriteValue", 0, 0, 0, number, napi_default, 0 },
+      { "readonlyValue", 0, 0, 0, number, napi_read_only, 0},
+      { "hiddenValue", 0, 0, 0, number, napi_read_only | napi_dont_enum, 0},
+  };
+
+  napi_value cons;
+  status = napi_define_class(env, "MyObject", New,
+    NULL, sizeof(properties)/sizeof(*properties), properties, &cons);
+  if (status != napi_ok) return;
+
+  status = napi_set_named_property(env, module, "exports", cons);
+  if (status != napi_ok) return;
+
+  status = napi_create_reference(env, cons, 1, &constructor_);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_conversions/binding.gyp b/test/addons-napi/test_conversions/binding.gyp
new file mode 100644
index 00000000000000..8d8d6fc0128294
--- /dev/null
+++ b/test/addons-napi/test_conversions/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_conversions",
+      "sources": [ "test_conversions.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_conversions/test.js b/test/addons-napi/test_conversions/test.js
new file mode 100644
index 00000000000000..73d2c3314f600b
--- /dev/null
+++ b/test/addons-napi/test_conversions/test.js
@@ -0,0 +1,140 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const test = require(`./build/${common.buildType}/test_conversions`);
+
+const boolExpected = /boolean was expected/;
+const numberExpected = /number was expected/;
+const stringExpected = /string was expected/;
+
+const testSym = Symbol('test');
+
+assert.strictEqual(false, test.asBool(false));
+assert.strictEqual(true, test.asBool(true));
+assert.throws(() => test.asBool(undefined), boolExpected);
+assert.throws(() => test.asBool(null), boolExpected);
+assert.throws(() => test.asBool(Number.NaN), boolExpected);
+assert.throws(() => test.asBool(0), boolExpected);
+assert.throws(() => test.asBool(''), boolExpected);
+assert.throws(() => test.asBool('0'), boolExpected);
+assert.throws(() => test.asBool(1), boolExpected);
+assert.throws(() => test.asBool('1'), boolExpected);
+assert.throws(() => test.asBool('true'), boolExpected);
+assert.throws(() => test.asBool({}), boolExpected);
+assert.throws(() => test.asBool([]), boolExpected);
+assert.throws(() => test.asBool(testSym), boolExpected);
+
+[test.asInt32, test.asUInt32, test.asInt64].forEach((asInt) => {
+  assert.strictEqual(0, asInt(0));
+  assert.strictEqual(1, asInt(1));
+  assert.strictEqual(1, asInt(1.0));
+  assert.strictEqual(1, asInt(1.1));
+  assert.strictEqual(1, asInt(1.9));
+  assert.strictEqual(0, asInt(0.9));
+  assert.strictEqual(999, asInt(999.9));
+  assert.strictEqual(0, asInt(Number.NaN));
+  assert.throws(() => asInt(undefined), numberExpected);
+  assert.throws(() => asInt(null), numberExpected);
+  assert.throws(() => asInt(false), numberExpected);
+  assert.throws(() => asInt(''), numberExpected);
+  assert.throws(() => asInt('1'), numberExpected);
+  assert.throws(() => asInt({}), numberExpected);
+  assert.throws(() => asInt([]), numberExpected);
+  assert.throws(() => asInt(testSym), numberExpected);
+});
+
+assert.strictEqual(-1, test.asInt32(-1));
+assert.strictEqual(-1, test.asInt64(-1));
+assert.strictEqual(Math.pow(2, 32) - 1, test.asUInt32(-1));
+
+assert.strictEqual(0, test.asDouble(0));
+assert.strictEqual(1, test.asDouble(1));
+assert.strictEqual(1.0, test.asDouble(1.0));
+assert.strictEqual(1.1, test.asDouble(1.1));
+assert.strictEqual(1.9, test.asDouble(1.9));
+assert.strictEqual(0.9, test.asDouble(0.9));
+assert.strictEqual(999.9, test.asDouble(999.9));
+assert.strictEqual(-1, test.asDouble(-1));
+assert.ok(Number.isNaN(test.asDouble(Number.NaN)));
+assert.throws(() => test.asDouble(undefined), numberExpected);
+assert.throws(() => test.asDouble(null), numberExpected);
+assert.throws(() => test.asDouble(false), numberExpected);
+assert.throws(() => test.asDouble(''), numberExpected);
+assert.throws(() => test.asDouble('1'), numberExpected);
+assert.throws(() => test.asDouble({}), numberExpected);
+assert.throws(() => test.asDouble([]), numberExpected);
+assert.throws(() => test.asDouble(testSym), numberExpected);
+
+assert.strictEqual('', test.asString(''));
+assert.strictEqual('test', test.asString('test'));
+assert.throws(() => test.asString(undefined), stringExpected);
+assert.throws(() => test.asString(null), stringExpected);
+assert.throws(() => test.asString(false), stringExpected);
+assert.throws(() => test.asString(1), stringExpected);
+assert.throws(() => test.asString(1.1), stringExpected);
+assert.throws(() => test.asString(Number.NaN), stringExpected);
+assert.throws(() => test.asString({}), stringExpected);
+assert.throws(() => test.asString([]), stringExpected);
+assert.throws(() => test.asString(testSym), stringExpected);
+
+assert.strictEqual(true, test.toBool(true));
+assert.strictEqual(true, test.toBool(1));
+assert.strictEqual(true, test.toBool(-1));
+assert.strictEqual(true, test.toBool('true'));
+assert.strictEqual(true, test.toBool('false'));
+assert.strictEqual(true, test.toBool({}));
+assert.strictEqual(true, test.toBool([]));
+assert.strictEqual(true, test.toBool(testSym));
+assert.strictEqual(false, test.toBool(false));
+assert.strictEqual(false, test.toBool(undefined));
+assert.strictEqual(false, test.toBool(null));
+assert.strictEqual(false, test.toBool(0));
+assert.strictEqual(false, test.toBool(Number.NaN));
+assert.strictEqual(false, test.toBool(''));
+
+assert.strictEqual(0, test.toNumber(0));
+assert.strictEqual(1, test.toNumber(1));
+assert.strictEqual(1.1, test.toNumber(1.1));
+assert.strictEqual(-1, test.toNumber(-1));
+assert.strictEqual(0, test.toNumber('0'));
+assert.strictEqual(1, test.toNumber('1'));
+assert.strictEqual(1.1, test.toNumber('1.1'));
+assert.strictEqual(0, test.toNumber([]));
+assert.strictEqual(0, test.toNumber(false));
+assert.strictEqual(0, test.toNumber(null));
+assert.strictEqual(0, test.toNumber(''));
+assert.ok(Number.isNaN(test.toNumber(Number.NaN)));
+assert.ok(Number.isNaN(test.toNumber({})));
+assert.ok(Number.isNaN(test.toNumber(undefined)));
+assert.throws(() => test.toNumber(testSym), TypeError);
+
+assert.deepStrictEqual({}, test.toObject({}));
+assert.deepStrictEqual({ 'test': 1 }, test.toObject({ 'test': 1 }));
+assert.deepStrictEqual([], test.toObject([]));
+assert.deepStrictEqual([ 1, 2, 3 ], test.toObject([ 1, 2, 3 ]));
+assert.deepStrictEqual(new Boolean(false), test.toObject(false));
+assert.deepStrictEqual(new Boolean(true), test.toObject(true));
+assert.deepStrictEqual(new String(''), test.toObject(''));
+assert.deepStrictEqual(new Number(0), test.toObject(0));
+assert.deepStrictEqual(new Number(Number.NaN), test.toObject(Number.NaN));
+assert.deepStrictEqual(new Object(testSym), test.toObject(testSym));
+assert.notDeepStrictEqual(false, test.toObject(false));
+assert.notDeepStrictEqual(true, test.toObject(true));
+assert.notDeepStrictEqual('', test.toObject(''));
+assert.notDeepStrictEqual(0, test.toObject(0));
+assert.ok(!Number.isNaN(test.toObject(Number.NaN)));
+
+assert.strictEqual('', test.toString(''));
+assert.strictEqual('test', test.toString('test'));
+assert.strictEqual('undefined', test.toString(undefined));
+assert.strictEqual('null', test.toString(null));
+assert.strictEqual('false', test.toString(false));
+assert.strictEqual('true', test.toString(true));
+assert.strictEqual('0', test.toString(0));
+assert.strictEqual('1.1', test.toString(1.1));
+assert.strictEqual('NaN', test.toString(Number.NaN));
+assert.strictEqual('[object Object]', test.toString({}));
+assert.strictEqual('test', test.toString({ toString: () => 'test' }));
+assert.strictEqual('', test.toString([]));
+assert.strictEqual('1,2,3', test.toString([ 1, 2, 3 ]));
+assert.throws(() => test.toString(testSym), TypeError);
diff --git a/test/addons-napi/test_conversions/test_conversions.c b/test/addons-napi/test_conversions/test_conversions.c
new file mode 100644
index 00000000000000..5fc8b0f2638c5a
--- /dev/null
+++ b/test/addons-napi/test_conversions/test_conversions.c
@@ -0,0 +1,237 @@
+#include <node_api.h>
+
+void ThrowLastError(napi_env env) {
+  const napi_extended_error_info* error_info;
+  napi_get_last_error_info(env, &error_info);
+  if (error_info->error_code != napi_ok) {
+    napi_throw_error(env, error_info->error_message);
+  }
+}
+
+void AsBool(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value input;
+  status = napi_get_cb_args(env, info, &input, 1);
+  if (status != napi_ok) goto done;
+
+  bool value;
+  status = napi_get_value_bool(env, input, &value);
+  if (status != napi_ok) goto done;
+
+  napi_value output;
+  status = napi_get_boolean(env, value, &output);
+  if (status != napi_ok) goto done;
+
+  status = napi_set_return_value(env, info, output);
+  if (status != napi_ok) goto done;
+
+done:
+  if (status != napi_ok) ThrowLastError(env);
+}
+
+void AsInt32(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value input;
+  status = napi_get_cb_args(env, info, &input, 1);
+  if (status != napi_ok) goto done;
+
+  int32_t value;
+  status = napi_get_value_int32(env, input, &value);
+  if (status != napi_ok) goto done;
+
+  napi_value output;
+  status = napi_create_number(env, value, &output);
+  if (status != napi_ok) goto done;
+
+  status = napi_set_return_value(env, info, output);
+  if (status != napi_ok) goto done;
+
+done:
+  if (status != napi_ok) ThrowLastError(env);
+}
+
+void AsUInt32(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value input;
+  status = napi_get_cb_args(env, info, &input, 1);
+  if (status != napi_ok) goto done;
+
+  uint32_t value;
+  status = napi_get_value_uint32(env, input, &value);
+  if (status != napi_ok) goto done;
+
+  napi_value output;
+  status = napi_create_number(env, value, &output);
+  if (status != napi_ok) goto done;
+
+  status = napi_set_return_value(env, info, output);
+  if (status != napi_ok) goto done;
+
+done:
+  if (status != napi_ok) ThrowLastError(env);
+}
+
+void AsInt64(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value input;
+  status = napi_get_cb_args(env, info, &input, 1);
+  if (status != napi_ok) goto done;
+
+  int64_t value;
+  status = napi_get_value_int64(env, input, &value);
+  if (status != napi_ok) goto done;
+
+  napi_value output;
+  status = napi_create_number(env, (double)value, &output);
+  if (status != napi_ok) goto done;
+
+  status = napi_set_return_value(env, info, output);
+  if (status != napi_ok) goto done;
+
+done:
+  if (status != napi_ok) ThrowLastError(env);
+}
+
+void AsDouble(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value input;
+  status = napi_get_cb_args(env, info, &input, 1);
+  if (status != napi_ok) goto done;
+
+  double value;
+  status = napi_get_value_double(env, input, &value);
+  if (status != napi_ok) goto done;
+
+  napi_value output;
+  status = napi_create_number(env, value, &output);
+  if (status != napi_ok) goto done;
+
+  status = napi_set_return_value(env, info, output);
+  if (status != napi_ok) goto done;
+
+done:
+  if (status != napi_ok) ThrowLastError(env);
+}
+
+void AsString(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value input;
+  status = napi_get_cb_args(env, info, &input, 1);
+  if (status != napi_ok) goto done;
+
+  char value[100];
+  status = napi_get_value_string_utf8(env, input, value, sizeof(value), NULL);
+  if (status != napi_ok) goto done;
+
+  napi_value output;
+  status = napi_create_string_utf8(env, value, -1, &output);
+  if (status != napi_ok) goto done;
+
+  status = napi_set_return_value(env, info, output);
+  if (status != napi_ok) goto done;
+
+done:
+  if (status != napi_ok) ThrowLastError(env);
+}
+
+void ToBool(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value input;
+  status = napi_get_cb_args(env, info, &input, 1);
+  if (status != napi_ok) goto done;
+
+  napi_value output;
+  status = napi_coerce_to_bool(env, input, &output);
+  if (status != napi_ok) goto done;
+
+  status = napi_set_return_value(env, info, output);
+  if (status != napi_ok) goto done;
+
+done:
+  if (status != napi_ok) ThrowLastError(env);
+}
+
+void ToNumber(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value input;
+  status = napi_get_cb_args(env, info, &input, 1);
+  if (status != napi_ok) goto done;
+
+  napi_value output;
+  status = napi_coerce_to_number(env, input, &output);
+  if (status != napi_ok) goto done;
+
+  status = napi_set_return_value(env, info, output);
+  if (status != napi_ok) goto done;
+
+done:
+  if (status != napi_ok) ThrowLastError(env);
+}
+
+void ToObject(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value input;
+  status = napi_get_cb_args(env, info, &input, 1);
+  if (status != napi_ok) goto done;
+
+  napi_value output;
+  status = napi_coerce_to_object(env, input, &output);
+  if (status != napi_ok) goto done;
+
+  status = napi_set_return_value(env, info, output);
+  if (status != napi_ok) goto done;
+
+done:
+  if (status != napi_ok) ThrowLastError(env);
+}
+
+void ToString(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value input;
+  status = napi_get_cb_args(env, info, &input, 1);
+  if (status != napi_ok) goto done;
+
+  napi_value output;
+  status = napi_coerce_to_string(env, input, &output);
+  if (status != napi_ok) goto done;
+
+  status = napi_set_return_value(env, info, output);
+  if (status != napi_ok) goto done;
+
+done:
+  if (status != napi_ok) ThrowLastError(env);
+}
+
+#define DECLARE_NAPI_METHOD(name, func)     \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_property_descriptor descriptors[] = {
+      DECLARE_NAPI_METHOD("asBool", AsBool),
+      DECLARE_NAPI_METHOD("asInt32", AsInt32),
+      DECLARE_NAPI_METHOD("asUInt32", AsUInt32),
+      DECLARE_NAPI_METHOD("asInt64", AsInt64),
+      DECLARE_NAPI_METHOD("asDouble", AsDouble),
+      DECLARE_NAPI_METHOD("asString", AsString),
+      DECLARE_NAPI_METHOD("toBool", ToBool),
+      DECLARE_NAPI_METHOD("toNumber", ToNumber),
+      DECLARE_NAPI_METHOD("toObject", ToObject),
+      DECLARE_NAPI_METHOD("toString", ToString),
+  };
+
+  napi_status status = napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_error/binding.gyp b/test/addons-napi/test_error/binding.gyp
new file mode 100644
index 00000000000000..c2defd9551a31b
--- /dev/null
+++ b/test/addons-napi/test_error/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_error",
+      "sources": [ "test_error.cc" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_error/test.js b/test/addons-napi/test_error/test.js
new file mode 100644
index 00000000000000..521c29250d5ffa
--- /dev/null
+++ b/test/addons-napi/test_error/test.js
@@ -0,0 +1,57 @@
+'use strict';
+
+const common = require('../../common');
+const test_error = require(`./build/${common.buildType}/test_error`);
+const assert = require('assert');
+const theError = new Error('Some error');
+const theTypeError = new TypeError('Some type error');
+const theSyntaxError = new SyntaxError('Some syntax error');
+const theRangeError = new RangeError('Some type error');
+const theReferenceError = new ReferenceError('Some reference error');
+const theURIError = new URIError('Some URI error');
+const theEvalError = new EvalError('Some eval error');
+
+class MyError extends Error { }
+const myError = new MyError('Some MyError');
+
+// Test that native error object is correctly classed
+assert.strictEqual(test_error.checkError(theError), true,
+                   'Error object correctly classed by napi_is_error');
+
+// Test that native type error object is correctly classed
+assert.strictEqual(test_error.checkError(theTypeError), true,
+                   'Type error object correctly classed by napi_is_error');
+
+// Test that native syntax error object is correctly classed
+assert.strictEqual(test_error.checkError(theSyntaxError), true,
+                   'Syntax error object correctly classed by napi_is_error');
+
+// Test that native range error object is correctly classed
+assert.strictEqual(test_error.checkError(theRangeError), true,
+                   'Range error object correctly classed by napi_is_error');
+
+// Test that native reference error object is correctly classed
+assert.strictEqual(test_error.checkError(theReferenceError), true,
+                   'Reference error object correctly classed by' +
+                   ' napi_is_error');
+
+// Test that native URI error object is correctly classed
+assert.strictEqual(test_error.checkError(theURIError), true,
+                   'URI error object correctly classed by napi_is_error');
+
+// Test that native eval error object is correctly classed
+assert.strictEqual(test_error.checkError(theEvalError), true,
+                   'Eval error object correctly classed by napi_is_error');
+
+// Test that class derived from native error is correctly classed
+assert.strictEqual(test_error.checkError(myError), true,
+                   'Class derived from native error correctly classed by' +
+                   ' napi_is_error');
+
+// Test that non-error object is correctly classed
+assert.strictEqual(test_error.checkError({}), false,
+                   'Non-error object correctly classed by napi_is_error');
+
+// Test that non-error primitive is correctly classed
+assert.strictEqual(test_error.checkError('non-object'), false,
+                   'Non-error primitive correctly classed by napi_is_error');
diff --git a/test/addons-napi/test_error/test_error.cc b/test/addons-napi/test_error/test_error.cc
new file mode 100644
index 00000000000000..1395cb5c4e1976
--- /dev/null
+++ b/test/addons-napi/test_error/test_error.cc
@@ -0,0 +1,37 @@
+#include <node_api.h>
+
+void checkError(napi_env e, napi_callback_info info) {
+  napi_status status;
+  napi_value jsError;
+
+  status = napi_get_cb_args(e, info, &jsError, 1);
+  if (status != napi_ok) return;
+
+  bool r;
+  status = napi_is_error(e, jsError, &r);
+  if (status != napi_ok) return;
+
+  napi_value result;
+  status = napi_get_boolean(e, r, &result);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(e, info, result);
+  if (status != napi_ok) return;
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+
+  napi_property_descriptor descriptors[] = {
+      DECLARE_NAPI_METHOD("checkError", checkError),
+  };
+
+  status = napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_exception/binding.gyp b/test/addons-napi/test_exception/binding.gyp
new file mode 100644
index 00000000000000..d2e4586e46bc1e
--- /dev/null
+++ b/test/addons-napi/test_exception/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_exception",
+      "sources": [ "test_exception.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_exception/test.js b/test/addons-napi/test_exception/test.js
new file mode 100644
index 00000000000000..83d2b5000ec54a
--- /dev/null
+++ b/test/addons-napi/test_exception/test.js
@@ -0,0 +1,53 @@
+'use strict';
+
+const common = require('../../common');
+const test_exception = require(`./build/${common.buildType}/test_exception`);
+const assert = require('assert');
+const theError = new Error('Some error');
+const throwTheError = function() {
+  throw theError;
+};
+let caughtError;
+
+const throwNoError = function() {};
+
+// Test that the native side successfully captures the exception
+let returnedError = test_exception.returnException(throwTheError);
+assert.strictEqual(theError, returnedError,
+                   'Returned error is strictly equal to the thrown error');
+
+// Test that the native side passes the exception through
+assert.throws(
+  () => {
+    test_exception.allowException(throwTheError);
+  },
+  function(err) {
+    return err === theError;
+  },
+  'Thrown exception was allowed to pass through unhindered'
+);
+
+// Test that the exception thrown above was marked as pending
+// before it was handled on the JS side
+assert.strictEqual(test_exception.wasPending(), true,
+                   'VM was marked as having an exception pending' +
+                   ' when it was allowed through');
+
+// Test that the native side does not capture a non-existing exception
+returnedError = test_exception.returnException(throwNoError);
+assert.strictEqual(undefined, returnedError,
+                   'Returned error is undefined when no exception is thrown');
+
+// Test that no exception appears that was not thrown by us
+try {
+  test_exception.allowException(throwNoError);
+} catch (anError) {
+  caughtError = anError;
+}
+assert.strictEqual(undefined, caughtError,
+                   'No exception originated on the native side');
+
+// Test that the exception state remains clear when no exception is thrown
+assert.strictEqual(test_exception.wasPending(), false,
+                   'VM was not marked as having an exception pending' +
+                   ' when none was allowed through');
diff --git a/test/addons-napi/test_exception/test_exception.c b/test/addons-napi/test_exception/test_exception.c
new file mode 100644
index 00000000000000..f92bae323d85e2
--- /dev/null
+++ b/test/addons-napi/test_exception/test_exception.c
@@ -0,0 +1,75 @@
+#include <node_api.h>
+
+static bool exceptionWasPending = false;
+
+void returnException(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value jsFunction;
+
+  status = napi_get_cb_args(env, info, &jsFunction, 1);
+  if (status != napi_ok) return;
+
+  napi_value global;
+  status = napi_get_global(env, &global);
+  if (status != napi_ok) return;
+
+  napi_value result;
+  status = napi_call_function(env, global, jsFunction, 0, 0, &result);
+  if (status ==  napi_pending_exception) {
+    napi_value ex;
+    status = napi_get_and_clear_last_exception(env, &ex);
+    if (status != napi_ok) return;
+
+    status = napi_set_return_value(env, info, ex);
+    if (status != napi_ok) return;
+  }
+}
+
+void allowException(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value jsFunction;
+
+  status = napi_get_cb_args(env, info, &jsFunction, 1);
+  if (status != napi_ok) return;
+
+  napi_value global;
+  status = napi_get_global(env, &global);
+  if (status != napi_ok) return;
+
+  napi_value result;
+  status = napi_call_function(env, global, jsFunction, 0, 0, &result);
+  // Ignore status and check napi_is_exception_pending() instead.
+
+  status = napi_is_exception_pending(env, &exceptionWasPending);
+  if (status != napi_ok) return;
+}
+
+void wasPending(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value result;
+  status = napi_get_boolean(env, exceptionWasPending, &result);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, result);
+  if (status != napi_ok) return;
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+
+  napi_property_descriptor descriptors[] = {
+      DECLARE_NAPI_METHOD("returnException", returnException),
+      DECLARE_NAPI_METHOD("allowException", allowException),
+      DECLARE_NAPI_METHOD("wasPending", wasPending),
+  };
+
+  status = napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_function/binding.gyp b/test/addons-napi/test_function/binding.gyp
new file mode 100644
index 00000000000000..2b015bddd7d222
--- /dev/null
+++ b/test/addons-napi/test_function/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_function",
+      "sources": [ "test_function.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_function/test.js b/test/addons-napi/test_function/test.js
new file mode 100644
index 00000000000000..bdb9133adf9346
--- /dev/null
+++ b/test/addons-napi/test_function/test.js
@@ -0,0 +1,28 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+
+// testing api calls for function
+const test_function = require(`./build/${common.buildType}/test_function`);
+
+
+function func1() {
+  return 1;
+}
+assert.strictEqual(test_function.Test(func1), 1);
+
+function func2() {
+  console.log('hello world!');
+  return null;
+}
+assert.strictEqual(test_function.Test(func2), null);
+
+function func3(input) {
+  return input + 1;
+}
+assert.strictEqual(test_function.Test(func3, 1), 2);
+
+function func4(input) {
+  return func3(input);
+}
+assert.strictEqual(test_function.Test(func4, 1), 2);
diff --git a/test/addons-napi/test_function/test_function.c b/test/addons-napi/test_function/test_function.c
new file mode 100644
index 00000000000000..1bd421e7bce617
--- /dev/null
+++ b/test/addons-napi/test_function/test_function.c
@@ -0,0 +1,55 @@
+#include <node_api.h>
+
+void Test(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc < 1) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value args[10];
+  status = napi_get_cb_args(env, info, args, 10);
+  if (status != napi_ok) return;
+
+  napi_valuetype valuetype;
+  status = napi_typeof(env, args[0], &valuetype);
+  if (status != napi_ok) return;
+
+  if (valuetype != napi_function) {
+    napi_throw_type_error(env, "Wrong type of argments. Expects a function.");
+    return;
+  }
+
+  napi_value function = args[0];
+  napi_value* argv = args + 1;
+  argc = argc - 1;
+
+  napi_value global;
+  status = napi_get_global(env, &global);
+  if (status != napi_ok) return;
+
+  napi_value result;
+  status = napi_call_function(env, global, function, argc, argv, &result);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, result);
+  if (status != napi_ok) return;
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+
+  napi_value fn;
+  status =  napi_create_function(env, NULL, Test, NULL, &fn);
+  if (status != napi_ok) return;
+
+  status = napi_set_named_property(env, exports, "Test", fn);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_instanceof/binding.gyp b/test/addons-napi/test_instanceof/binding.gyp
new file mode 100644
index 00000000000000..7fca7e0736d410
--- /dev/null
+++ b/test/addons-napi/test_instanceof/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_instanceof",
+      "sources": [ "test_instanceof.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_instanceof/test.js b/test/addons-napi/test_instanceof/test.js
new file mode 100644
index 00000000000000..38d17031e9a6c9
--- /dev/null
+++ b/test/addons-napi/test_instanceof/test.js
@@ -0,0 +1,87 @@
+'use strict';
+const fs = require('fs');
+
+const common = require('../../common');
+const assert = require('assert');
+
+// addon is referenced through the eval expression in testFile
+// eslint-disable-next-line no-unused-vars
+const addon = require(`./build/${common.buildType}/test_instanceof`);
+const path = require('path');
+
+// The following assert functions are referenced by v8's unit tests
+// See for instance deps/v8/test/mjsunit/instanceof.js
+// eslint-disable-next-line no-unused-vars
+function assertTrue(assertion) {
+  return assert.strictEqual(true, assertion);
+}
+
+// eslint-disable-next-line no-unused-vars
+function assertFalse(assertion) {
+  assert.strictEqual(false, assertion);
+}
+
+// eslint-disable-next-line no-unused-vars
+function assertEquals(leftHandSide, rightHandSide) {
+  assert.strictEqual(leftHandSide, rightHandSide);
+}
+
+// eslint-disable-next-line no-unused-vars
+function assertThrows(statement) {
+  assert.throws(function() {
+    eval(statement);
+  }, Error);
+}
+
+function testFile(fileName) {
+  const contents = fs.readFileSync(fileName, { encoding: 'utf8' });
+  eval(contents.replace(/[(]([^\s(]+)\s+instanceof\s+([^)]+)[)]/g,
+                        '(addon.doInstanceOf($1, $2))'));
+}
+
+testFile(
+    path.join(path.resolve(__dirname, '..', '..', '..',
+                           'deps', 'v8', 'test', 'mjsunit'),
+              'instanceof.js'));
+testFile(
+    path.join(path.resolve(__dirname, '..', '..', '..',
+                           'deps', 'v8', 'test', 'mjsunit'),
+              'instanceof-2.js'));
+
+// We can only perform this test if we have a working Symbol.hasInstance
+if (typeof Symbol !== 'undefined' && 'hasInstance' in Symbol &&
+    typeof Symbol.hasInstance === 'symbol') {
+
+  function compareToNative(theObject, theConstructor) {
+    assert.strictEqual(addon.doInstanceOf(theObject, theConstructor),
+      (theObject instanceof theConstructor));
+  }
+
+  const MyClass = function MyClass() {};
+  Object.defineProperty(MyClass, Symbol.hasInstance, {
+    value: function(candidate) {
+      return 'mark' in candidate;
+    }
+  });
+
+  const MySubClass = function MySubClass() {};
+  MySubClass.prototype = new MyClass();
+
+  let x = new MySubClass();
+  let y = new MySubClass();
+  x.mark = true;
+
+  compareToNative(x, MySubClass);
+  compareToNative(y, MySubClass);
+  compareToNative(x, MyClass);
+  compareToNative(y, MyClass);
+
+  x = new MyClass();
+  y = new MyClass();
+  x.mark = true;
+
+  compareToNative(x, MySubClass);
+  compareToNative(y, MySubClass);
+  compareToNative(x, MyClass);
+  compareToNative(y, MyClass);
+}
diff --git a/test/addons-napi/test_instanceof/test_instanceof.c b/test/addons-napi/test_instanceof/test_instanceof.c
new file mode 100644
index 00000000000000..76df14eb393ab3
--- /dev/null
+++ b/test/addons-napi/test_instanceof/test_instanceof.c
@@ -0,0 +1,39 @@
+#include <node_api.h>
+#include <stdio.h>
+
+void doInstanceOf(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value arguments[2];
+
+  status = napi_get_cb_args(env, info, arguments, 2);
+  if (status != napi_ok) return;
+
+  bool instanceof;
+  status = napi_instanceof(env, arguments[0], arguments[1], &instanceof);
+  if (status != napi_ok) return;
+
+  napi_value result;
+  status = napi_get_boolean(env, instanceof, &result);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, result);
+  if (status != napi_ok) return;
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+
+  napi_property_descriptor descriptors[] = {
+      DECLARE_NAPI_METHOD("doInstanceOf", doInstanceOf),
+  };
+
+  status = napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_number/binding.gyp b/test/addons-napi/test_number/binding.gyp
new file mode 100644
index 00000000000000..c934d5ef03bfc7
--- /dev/null
+++ b/test/addons-napi/test_number/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_number",
+      "sources": [ "test_number.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_number/test.js b/test/addons-napi/test_number/test.js
new file mode 100644
index 00000000000000..885b9b599d9f25
--- /dev/null
+++ b/test/addons-napi/test_number/test.js
@@ -0,0 +1,39 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const test_number = require(`./build/${common.buildType}/test_number`);
+
+
+// testing api calls for number
+assert.strictEqual(0, test_number.Test(0));
+assert.strictEqual(1, test_number.Test(1));
+assert.strictEqual(-1, test_number.Test(-1));
+assert.strictEqual(100, test_number.Test(100));
+assert.strictEqual(2121, test_number.Test(2121));
+assert.strictEqual(-1233, test_number.Test(-1233));
+assert.strictEqual(986583, test_number.Test(986583));
+assert.strictEqual(-976675, test_number.Test(-976675));
+
+const num1 = 98765432213456789876546896323445679887645323232436587988766545658;
+assert.strictEqual(num1, test_number.Test(num1));
+
+const num2 = -4350987086545760976737453646576078997096876957864353245245769809;
+assert.strictEqual(num2, test_number.Test(num2));
+
+const num3 = Number.MAX_SAFE_INTEGER;
+assert.strictEqual(num3, test_number.Test(num3));
+
+const num4 = Number.MAX_SAFE_INTEGER + 10;
+assert.strictEqual(num4, test_number.Test(num4));
+
+const num5 = Number.MAX_VALUE;
+assert.strictEqual(num5, test_number.Test(num5));
+
+const num6 = Number.MAX_VALUE + 10;
+assert.strictEqual(num6, test_number.Test(num6));
+
+const num7 = Number.POSITIVE_INFINITY;
+assert.strictEqual(num7, test_number.Test(num7));
+
+const num8 = Number.NEGATIVE_INFINITY;
+assert.strictEqual(num8, test_number.Test(num8));
diff --git a/test/addons-napi/test_number/test_number.c b/test/addons-napi/test_number/test_number.c
new file mode 100644
index 00000000000000..f38c09d6817ead
--- /dev/null
+++ b/test/addons-napi/test_number/test_number.c
@@ -0,0 +1,55 @@
+#include <node_api.h>
+
+void Test(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc < 1) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value args[1];
+  status = napi_get_cb_args(env, info, args, 1);
+  if (status != napi_ok) return;
+
+  napi_valuetype valuetype;
+  status = napi_typeof(env, args[0], &valuetype);
+  if (status != napi_ok) return;
+
+  if (valuetype != napi_number) {
+    napi_throw_type_error(env, "Wrong type of argments. Expects a number.");
+    return;
+  }
+
+  double input;
+  status = napi_get_value_double(env, args[0], &input);
+  if (status != napi_ok) return;
+
+  napi_value output;
+  status = napi_create_number(env, input, &output);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, output);
+  if (status != napi_ok) return;
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+
+  napi_property_descriptor descriptors[] = {
+      DECLARE_NAPI_METHOD("Test", Test),
+  };
+
+  status = napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_object/binding.gyp b/test/addons-napi/test_object/binding.gyp
new file mode 100644
index 00000000000000..be225ace779027
--- /dev/null
+++ b/test/addons-napi/test_object/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_object",
+      "sources": [ "test_object.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_object/test.js b/test/addons-napi/test_object/test.js
new file mode 100644
index 00000000000000..d14a15421feef6
--- /dev/null
+++ b/test/addons-napi/test_object/test.js
@@ -0,0 +1,65 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+
+// Testing api calls for objects
+const test_object = require(`./build/${common.buildType}/test_object`);
+
+
+const object = {
+  hello: 'world',
+  array: [
+    1, 94, 'str', 12.321, { test: 'obj in arr' }
+  ],
+  newObject: {
+    test: 'obj in obj'
+  }
+};
+
+assert.strictEqual(test_object.Get(object, 'hello'), 'world');
+assert.deepStrictEqual(test_object.Get(object, 'array'),
+                       [ 1, 94, 'str', 12.321, { test: 'obj in arr' } ]);
+assert.deepStrictEqual(test_object.Get(object, 'newObject'),
+                       { test: 'obj in obj' });
+
+assert(test_object.Has(object, 'hello'));
+assert(test_object.Has(object, 'array'));
+assert(test_object.Has(object, 'newObject'));
+
+const newObject = test_object.New();
+assert(test_object.Has(newObject, 'test_number'));
+assert.strictEqual(newObject.test_number, 987654321);
+assert.strictEqual(newObject.test_string, 'test string');
+
+// test_object.Inflate increases all properties by 1
+const cube = {
+  x: 10,
+  y: 10,
+  z: 10
+};
+
+assert.deepStrictEqual(test_object.Inflate(cube), {x: 11, y: 11, z: 11});
+assert.deepStrictEqual(test_object.Inflate(cube), {x: 12, y: 12, z: 12});
+assert.deepStrictEqual(test_object.Inflate(cube), {x: 13, y: 13, z: 13});
+cube.t = 13;
+assert.deepStrictEqual(test_object.Inflate(cube), {x: 14, y: 14, z: 14, t: 14});
+
+const sym1 = Symbol('1');
+const sym2 = Symbol('2');
+const sym3 = Symbol('3');
+const sym4 = Symbol('4');
+const object2 = {
+  [sym1]: '@@iterator',
+  [sym2]: sym3
+};
+
+assert(test_object.Has(object2, sym1));
+assert(test_object.Has(object2, sym2));
+assert.strictEqual(test_object.Get(object2, sym1), '@@iterator');
+assert.strictEqual(test_object.Get(object2, sym2), sym3);
+assert(test_object.Set(object2, 'string', 'value'));
+assert(test_object.Set(object2, sym4, 123));
+assert(test_object.Has(object2, 'string'));
+assert(test_object.Has(object2, sym4));
+assert.strictEqual(test_object.Get(object2, 'string'), 'value');
+assert.strictEqual(test_object.Get(object2, sym4), 123);
diff --git a/test/addons-napi/test_object/test_object.c b/test/addons-napi/test_object/test_object.c
new file mode 100644
index 00000000000000..6080201877cc6b
--- /dev/null
+++ b/test/addons-napi/test_object/test_object.c
@@ -0,0 +1,246 @@
+#include <node_api.h>
+
+void Get(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc < 2) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value args[2];
+  status = napi_get_cb_args(env, info, args, 2);
+  if (status != napi_ok) return;
+
+  napi_valuetype valuetype0;
+  status = napi_typeof(env, args[0], &valuetype0);
+  if (status != napi_ok) return;
+
+  if (valuetype0 != napi_object) {
+    napi_throw_type_error(
+        env, "Wrong type of argments. Expects an object as first argument.");
+    return;
+  }
+
+  napi_valuetype valuetype1;
+  status = napi_typeof(env, args[1], &valuetype1);
+  if (status != napi_ok) return;
+
+  if (valuetype1 != napi_string && valuetype1 != napi_symbol) {
+    napi_throw_type_error(env,
+        "Wrong type of argments. Expects a string or symbol as second.");
+    return;
+  }
+
+  napi_value object = args[0];
+  napi_value output;
+  status = napi_get_property(env, object, args[1], &output);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, output);
+  if (status != napi_ok) return;
+}
+
+void Set(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc < 3) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value args[3];
+  status = napi_get_cb_args(env, info, args, 3);
+  if (status != napi_ok) return;
+
+  napi_valuetype valuetype0;
+  status = napi_typeof(env, args[0], &valuetype0);
+  if (status != napi_ok) return;
+
+  if (valuetype0 != napi_object) {
+    napi_throw_type_error(env,
+        "Wrong type of argments. Expects an object as first argument.");
+    return;
+  }
+
+  napi_valuetype valuetype1;
+  status = napi_typeof(env, args[1], &valuetype1);
+  if (status != napi_ok) return;
+
+  if (valuetype1 != napi_string && valuetype1 != napi_symbol) {
+    napi_throw_type_error(env,
+        "Wrong type of argments. Expects a string or symbol as second.");
+    return;
+  }
+
+  napi_value object = args[0];
+  status = napi_set_property(env, object, args[1], args[2]);
+  if (status != napi_ok) return;
+
+  napi_value valuetrue;
+  status = napi_get_boolean(env, true, &valuetrue);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, valuetrue);
+  if (status != napi_ok) return;
+}
+
+void Has(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc < 2) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value args[2];
+  status = napi_get_cb_args(env, info, args, 2);
+  if (status != napi_ok) return;
+
+  napi_valuetype valuetype0;
+  status = napi_typeof(env, args[0], &valuetype0);
+  if (status != napi_ok) return;
+
+  if (valuetype0 != napi_object) {
+    napi_throw_type_error(
+        env, "Wrong type of argments. Expects an object as first argument.");
+    return;
+  }
+
+  napi_valuetype valuetype1;
+  status = napi_typeof(env, args[1], &valuetype1);
+  if (status != napi_ok) return;
+
+  if (valuetype1 != napi_string && valuetype1 != napi_symbol) {
+    napi_throw_type_error(env,
+        "Wrong type of argments. Expects a string or symbol as second.");
+    return;
+  }
+
+  napi_value obj = args[0];
+  bool has_property;
+  status = napi_has_property(env, obj, args[1], &has_property);
+  if (status != napi_ok) return;
+
+  napi_value ret;
+  status = napi_get_boolean(env, has_property, &ret);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, ret);
+  if (status != napi_ok) return;
+}
+
+void New(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  napi_value ret;
+  status = napi_create_object(env, &ret);
+
+  napi_value num;
+  status = napi_create_number(env, 987654321, &num);
+  if (status != napi_ok) return;
+
+  status = napi_set_named_property(env, ret, "test_number", num);
+  if (status != napi_ok) return;
+
+  napi_value str;
+  status = napi_create_string_utf8(env, "test string", -1, &str);
+  if (status != napi_ok) return;
+
+  status = napi_set_named_property(env, ret, "test_string", str);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, ret);
+  if (status != napi_ok) return;
+}
+
+void Inflate(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc < 1) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value args[1];
+  status = napi_get_cb_args(env, info, args, 1);
+  if (status != napi_ok) return;
+
+  napi_valuetype valuetype;
+  status = napi_typeof(env, args[0], &valuetype);
+  if (status != napi_ok) return;
+
+  if (valuetype != napi_object) {
+    napi_throw_type_error(
+        env, "Wrong type of argments. Expects an object as first argument.");
+    return;
+  }
+
+  napi_value obj = args[0];
+
+  napi_value propertynames;
+  status = napi_get_property_names(env, obj, &propertynames);
+  if (status != napi_ok) return;
+
+  uint32_t i, length;
+  status = napi_get_array_length(env, propertynames, &length);
+  if (status != napi_ok) return;
+
+  for (i = 0; i < length; i++) {
+    napi_value property_str;
+    status = napi_get_element(env, propertynames, i, &property_str);
+    if (status != napi_ok) return;
+
+    napi_value value;
+    status = napi_get_property(env, obj, property_str, &value);
+    if (status != napi_ok) return;
+
+    double double_val;
+    status = napi_get_value_double(env, value, &double_val);
+    if (status != napi_ok) return;
+
+    status = napi_create_number(env, double_val + 1, &value);
+    if (status != napi_ok) return;
+
+    status = napi_set_property(env, obj, property_str, value);
+    if (status != napi_ok) return;
+  }
+  status = napi_set_return_value(env, info, obj);
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+
+  napi_property_descriptor descriptors[] = {
+      DECLARE_NAPI_METHOD("Get", Get),
+      DECLARE_NAPI_METHOD("Set", Set),
+      DECLARE_NAPI_METHOD("Has", Has),
+      DECLARE_NAPI_METHOD("New", New),
+      DECLARE_NAPI_METHOD("Inflate", Inflate),
+  };
+
+  status = napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_properties/binding.gyp b/test/addons-napi/test_properties/binding.gyp
new file mode 100644
index 00000000000000..345e5c88d7c6b9
--- /dev/null
+++ b/test/addons-napi/test_properties/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_properties",
+      "sources": [ "test_properties.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_properties/test.js b/test/addons-napi/test_properties/test.js
new file mode 100644
index 00000000000000..8e19903dcfe6e6
--- /dev/null
+++ b/test/addons-napi/test_properties/test.js
@@ -0,0 +1,27 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+
+// Testing api calls for defining properties
+const test_object = require(`./build/${common.buildType}/test_properties`);
+
+assert.strictEqual(test_object.echo('hello'), 'hello');
+
+test_object.readwriteValue = 1;
+assert.strictEqual(test_object.readwriteValue, 1);
+test_object.readwriteValue = 2;
+assert.strictEqual(test_object.readwriteValue, 2);
+
+assert.throws(() => { test_object.readonlyValue = 3; });
+
+assert.ok(test_object.hiddenValue);
+
+// All properties except 'hiddenValue' should be enumerable.
+const propertyNames = [];
+for (const name in test_object) {
+  propertyNames.push(name);
+}
+assert.ok(propertyNames.indexOf('echo') >= 0);
+assert.ok(propertyNames.indexOf('readwriteValue') >= 0);
+assert.ok(propertyNames.indexOf('readonlyValue') >= 0);
+assert.ok(propertyNames.indexOf('hiddenValue') < 0);
diff --git a/test/addons-napi/test_properties/test_properties.c b/test/addons-napi/test_properties/test_properties.c
new file mode 100644
index 00000000000000..9474e97266649b
--- /dev/null
+++ b/test/addons-napi/test_properties/test_properties.c
@@ -0,0 +1,85 @@
+#include <node_api.h>
+
+static double value_ = 1;
+
+void GetValue(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc != 0) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value number;
+  status = napi_create_number(env, value_, &number);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, number);
+  if (status != napi_ok) return;
+}
+
+void SetValue(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc != 1) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value arg;
+  status = napi_get_cb_args(env, info, &arg, 1);
+  if (status != napi_ok) return;
+
+  status = napi_get_value_double(env, arg, &value_);
+  if (status != napi_ok) return;
+}
+
+void Echo(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc != 1) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value arg;
+  status = napi_get_cb_args(env, info, &arg, 1);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, arg);
+  if (status != napi_ok) return;
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+
+  napi_value number;
+  status = napi_create_number(env, value_, &number);
+  if (status != napi_ok) return;
+
+  napi_property_descriptor properties[] = {
+      { "echo", Echo, 0, 0, 0, napi_default, 0 },
+      { "accessorValue", 0, GetValue, SetValue, 0, napi_default, 0 },
+      { "readwriteValue", 0, 0, 0, number, napi_default, 0 },
+      { "readonlyValue", 0, 0, 0, number, napi_read_only, 0 },
+      { "hiddenValue", 0, 0, 0, number, napi_read_only | napi_dont_enum, 0 },
+  };
+
+  status = napi_define_properties(
+    env, exports, sizeof(properties) / sizeof(*properties), properties);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_string/binding.gyp b/test/addons-napi/test_string/binding.gyp
new file mode 100644
index 00000000000000..d4825de933985f
--- /dev/null
+++ b/test/addons-napi/test_string/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_string",
+      "sources": [ "test_string.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_string/test.js b/test/addons-napi/test_string/test.js
new file mode 100644
index 00000000000000..3c9334a5616523
--- /dev/null
+++ b/test/addons-napi/test_string/test.js
@@ -0,0 +1,26 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+
+// testing api calls for string
+const test_string = require(`./build/${common.buildType}/test_string`);
+
+const str1 = 'hello world';
+assert.strictEqual(test_string.Copy(str1), str1);
+assert.strictEqual(test_string.Length(str1), 11);
+assert.strictEqual(test_string.Utf8Length(str1), 11);
+
+const str2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+assert.strictEqual(test_string.Copy(str2), str2);
+assert.strictEqual(test_string.Length(str2), 62);
+assert.strictEqual(test_string.Utf8Length(str2), 62);
+
+const str3 = '?!@#$%^&*()_+-=[]{}/.,<>\'"\\';
+assert.strictEqual(test_string.Copy(str3), str3);
+assert.strictEqual(test_string.Length(str3), 27);
+assert.strictEqual(test_string.Utf8Length(str3), 27);
+
+const str4 = '\u{2003}\u{2101}\u{2001}';
+assert.strictEqual(test_string.Copy(str4), str4);
+assert.strictEqual(test_string.Length(str4), 3);
+assert.strictEqual(test_string.Utf8Length(str4), 9);
diff --git a/test/addons-napi/test_string/test_string.c b/test/addons-napi/test_string/test_string.c
new file mode 100644
index 00000000000000..1e9c8109d93942
--- /dev/null
+++ b/test/addons-napi/test_string/test_string.c
@@ -0,0 +1,134 @@
+#include <node_api.h>
+
+void Copy(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc < 1) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value args[1];
+  status = napi_get_cb_args(env, info, args, 1);
+  if (status != napi_ok) return;
+
+  napi_valuetype valuetype;
+  status = napi_typeof(env, args[0], &valuetype);
+  if (status != napi_ok) return;
+
+  if (valuetype != napi_string) {
+    napi_throw_type_error(env, "Wrong type of argments. Expects a string.");
+    return;
+  }
+
+  char buffer[128];
+  int buffer_size = 128;
+
+  status =
+      napi_get_value_string_utf8(env, args[0], buffer, buffer_size, NULL);
+  if (status != napi_ok) return;
+
+  napi_value output;
+  status = napi_create_string_utf8(env, buffer, -1, &output);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, output);
+  if (status != napi_ok) return;
+}
+
+void Length(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc < 1) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value args[1];
+  status = napi_get_cb_args(env, info, args, 1);
+  if (status != napi_ok) return;
+
+  napi_valuetype valuetype;
+  status = napi_typeof(env, args[0], &valuetype);
+  if (status != napi_ok) return;
+
+  if (valuetype != napi_string) {
+    napi_throw_type_error(env, "Wrong type of argments. Expects a string.");
+    return;
+  }
+
+  size_t length;
+  status = napi_get_value_string_length(env, args[0], &length);
+  if (status != napi_ok) return;
+
+  napi_value output;
+  status = napi_create_number(env, (double)length, &output);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, output);
+  if (status != napi_ok) return;
+}
+
+void Utf8Length(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc < 1) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value args[1];
+  status = napi_get_cb_args(env, info, args, 1);
+  if (status != napi_ok) return;
+
+  napi_valuetype valuetype;
+  status = napi_typeof(env, args[0], &valuetype);
+  if (status != napi_ok) return;
+
+  if (valuetype != napi_string) {
+    napi_throw_type_error(env, "Wrong type of argments. Expects a string.");
+    return;
+  }
+
+  size_t length;
+  status = napi_get_value_string_utf8(env, args[0], NULL, 0, &length);
+  if (status != napi_ok) return;
+
+  napi_value output;
+  status = napi_create_number(env, (double)length, &output);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, output);
+  if (status != napi_ok) return;
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+
+  napi_property_descriptor properties[] = {
+      DECLARE_NAPI_METHOD("Copy", Copy),
+      DECLARE_NAPI_METHOD("Length", Length),
+      DECLARE_NAPI_METHOD("Utf8Length", Utf8Length),
+  };
+
+  status = napi_define_properties(
+      env, exports, sizeof(properties) / sizeof(*properties), properties);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_symbol/binding.gyp b/test/addons-napi/test_symbol/binding.gyp
new file mode 100644
index 00000000000000..6ef3407968db94
--- /dev/null
+++ b/test/addons-napi/test_symbol/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_symbol",
+      "sources": [ "test_symbol.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_symbol/test1.js b/test/addons-napi/test_symbol/test1.js
new file mode 100644
index 00000000000000..25eb473c4b1b9d
--- /dev/null
+++ b/test/addons-napi/test_symbol/test1.js
@@ -0,0 +1,20 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+
+// testing api calls for symbol
+const test_symbol = require(`./build/${common.buildType}/test_symbol`);
+
+const sym = test_symbol.New('test');
+assert.strictEqual(sym.toString(), 'Symbol(test)');
+
+
+const myObj = {};
+const fooSym = test_symbol.New('foo');
+const otherSym = test_symbol.New('bar');
+myObj['foo'] = 'bar';
+myObj[fooSym] = 'baz';
+myObj[otherSym] = 'bing';
+assert.strictEqual(myObj.foo, 'bar');
+assert.strictEqual(myObj[fooSym], 'baz');
+assert.strictEqual(myObj[otherSym], 'bing');
diff --git a/test/addons-napi/test_symbol/test2.js b/test/addons-napi/test_symbol/test2.js
new file mode 100644
index 00000000000000..60512431110a5b
--- /dev/null
+++ b/test/addons-napi/test_symbol/test2.js
@@ -0,0 +1,15 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+
+// testing api calls for symbol
+const test_symbol = require(`./build/${common.buildType}/test_symbol`);
+
+const fooSym = test_symbol.New('foo');
+const myObj = {};
+myObj['foo'] = 'bar';
+myObj[fooSym] = 'baz';
+Object.keys(myObj); // -> [ 'foo' ]
+Object.getOwnPropertyNames(myObj); // -> [ 'foo' ]
+Object.getOwnPropertySymbols(myObj); // -> [ Symbol(foo) ]
+assert.strictEqual(Object.getOwnPropertySymbols(myObj)[0], fooSym);
diff --git a/test/addons-napi/test_symbol/test3.js b/test/addons-napi/test_symbol/test3.js
new file mode 100644
index 00000000000000..a7c6c18c025480
--- /dev/null
+++ b/test/addons-napi/test_symbol/test3.js
@@ -0,0 +1,19 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+
+// testing api calls for symbol
+const test_symbol = require(`./build/${common.buildType}/test_symbol`);
+
+assert.notStrictEqual(test_symbol.New(), test_symbol.New());
+assert.notStrictEqual(test_symbol.New('foo'), test_symbol.New('foo'));
+assert.notStrictEqual(test_symbol.New('foo'), test_symbol.New('bar'));
+
+const foo1 = test_symbol.New('foo');
+const foo2 = test_symbol.New('foo');
+const object = {
+  [foo1]: 1,
+  [foo2]: 2,
+};
+assert.strictEqual(object[foo1], 1);
+assert.strictEqual(object[foo2], 2);
diff --git a/test/addons-napi/test_symbol/test_symbol.c b/test/addons-napi/test_symbol/test_symbol.c
new file mode 100644
index 00000000000000..af694b1dd3543b
--- /dev/null
+++ b/test/addons-napi/test_symbol/test_symbol.c
@@ -0,0 +1,94 @@
+#include <node_api.h>
+
+void Test(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc < 1) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value args[1];
+  status = napi_get_cb_args(env, info, args, 1);
+  if (status != napi_ok) return;
+
+  napi_valuetype valuetype;
+  status = napi_typeof(env, args[0], &valuetype);
+  if (status != napi_ok) return;
+
+  if (valuetype != napi_symbol) {
+    napi_throw_type_error(env, "Wrong type of argments. Expects a symbol.");
+    return;
+  }
+
+  char buffer[128];
+  int buffer_size = 128;
+
+  status =
+      napi_get_value_string_utf8(env, args[0], buffer, buffer_size, NULL);
+  if (status != napi_ok) return;
+
+  napi_value output;
+  status = napi_create_string_utf8(env, buffer, -1, &output);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, output);
+  if (status != napi_ok) return;
+}
+
+void New(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc >= 1) {
+    napi_value args[1];
+    napi_get_cb_args(env, info, args, 1);
+
+    napi_valuetype valuetype;
+    status = napi_typeof(env, args[0], &valuetype);
+    if (status != napi_ok) return;
+
+    if (valuetype != napi_string) {
+      napi_throw_type_error(env, "Wrong type of argments. Expects a string.");
+      return;
+    }
+
+    napi_value symbol;
+    status = napi_create_symbol(env, args[0], &symbol);
+    if (status != napi_ok) return;
+
+    status = napi_set_return_value(env, info, symbol);
+    if (status != napi_ok) return;
+  } else {
+    napi_value symbol;
+    status = napi_create_symbol(env, NULL, &symbol);
+    if (status != napi_ok) return;
+
+    status = napi_set_return_value(env, info, symbol);
+    if (status != napi_ok) return;
+  }
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+
+  napi_property_descriptor properties[] = {
+      DECLARE_NAPI_METHOD("New", New),
+  };
+
+  status = napi_define_properties(
+      env, exports, sizeof(properties) / sizeof(*properties), properties);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_typedarray/binding.gyp b/test/addons-napi/test_typedarray/binding.gyp
new file mode 100644
index 00000000000000..8b4a4dc622b2ef
--- /dev/null
+++ b/test/addons-napi/test_typedarray/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_typedarray",
+      "sources": [ "test_typedarray.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_typedarray/test.js b/test/addons-napi/test_typedarray/test.js
new file mode 100644
index 00000000000000..cc1fcbe3566da3
--- /dev/null
+++ b/test/addons-napi/test_typedarray/test.js
@@ -0,0 +1,39 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+
+// Testing api calls for arrays
+const test_typedarray = require(`./build/${common.buildType}/test_typedarray`);
+
+const byteArray = new Uint8Array(3);
+byteArray[0] = 0;
+byteArray[1] = 1;
+byteArray[2] = 2;
+assert.strictEqual(byteArray.length, 3);
+
+const doubleArray = new Float64Array(3);
+doubleArray[0] = 0.0;
+doubleArray[1] = 1.1;
+doubleArray[2] = 2.2;
+assert.strictEqual(doubleArray.length, 3);
+
+const byteResult = test_typedarray.Multiply(byteArray, 3);
+assert.ok(byteResult instanceof Uint8Array);
+assert.strictEqual(byteResult.length, 3);
+assert.strictEqual(byteResult[0], 0);
+assert.strictEqual(byteResult[1], 3);
+assert.strictEqual(byteResult[2], 6);
+
+const doubleResult = test_typedarray.Multiply(doubleArray, -3);
+assert.ok(doubleResult instanceof Float64Array);
+assert.strictEqual(doubleResult.length, 3);
+assert.strictEqual(doubleResult[0], 0);
+assert.strictEqual(Math.round(10 * doubleResult[1]) / 10, -3.3);
+assert.strictEqual(Math.round(10 * doubleResult[2]) / 10, -6.6);
+
+const externalResult = test_typedarray.External();
+assert.ok(externalResult instanceof Int8Array);
+assert.strictEqual(externalResult.length, 3);
+assert.strictEqual(externalResult[0], 0);
+assert.strictEqual(externalResult[1], 1);
+assert.strictEqual(externalResult[2], 2);
diff --git a/test/addons-napi/test_typedarray/test_typedarray.c b/test/addons-napi/test_typedarray/test_typedarray.c
new file mode 100644
index 00000000000000..00217a8cc0d18f
--- /dev/null
+++ b/test/addons-napi/test_typedarray/test_typedarray.c
@@ -0,0 +1,144 @@
+#include <node_api.h>
+#include <string.h>
+
+void Multiply(napi_env env, napi_callback_info info) {
+  napi_status status;
+
+  size_t argc;
+  status = napi_get_cb_args_length(env, info, &argc);
+  if (status != napi_ok) return;
+
+  if (argc != 2) {
+    napi_throw_type_error(env, "Wrong number of arguments");
+    return;
+  }
+
+  napi_value args[2];
+  status = napi_get_cb_args(env, info, args, 2);
+  if (status != napi_ok) return;
+
+  napi_valuetype valuetype0;
+  status = napi_typeof(env, args[0], &valuetype0);
+  if (status != napi_ok) return;
+
+  if (valuetype0 != napi_object) {
+    napi_throw_type_error(
+        env,
+        "Wrong type of argments. Expects a typed array as first argument.");
+    return;
+  }
+
+  napi_value input_array = args[0];
+  bool istypedarray;
+  status = napi_is_typedarray(env, input_array, &istypedarray);
+  if (status != napi_ok) return;
+
+  if (!istypedarray) {
+    napi_throw_type_error(
+        env,
+        "Wrong type of argments. Expects a typed array as first argument.");
+    return;
+  }
+
+  napi_valuetype valuetype1;
+  status = napi_typeof(env, args[1], &valuetype1);
+  if (status != napi_ok) return;
+
+  if (valuetype1 != napi_number) {
+    napi_throw_type_error(
+        env, "Wrong type of argments. Expects a number as second argument.");
+    return;
+  }
+
+  double multiplier;
+  status = napi_get_value_double(env, args[1], &multiplier);
+  if (status != napi_ok) return;
+
+  napi_typedarray_type type;
+  napi_value input_buffer;
+  size_t byte_offset;
+  size_t i, length;
+  status = napi_get_typedarray_info(
+      env, input_array, &type, &length, NULL, &input_buffer, &byte_offset);
+  if (status != napi_ok) return;
+
+  void* data;
+  size_t byte_length;
+  status = napi_get_arraybuffer_info(env, input_buffer, &data, &byte_length);
+  if (status != napi_ok) return;
+
+  napi_value output_buffer;
+  void* output_ptr = NULL;
+  status =
+      napi_create_arraybuffer(env, byte_length, &output_ptr, &output_buffer);
+  if (status != napi_ok) return;
+
+  napi_value output_array;
+  status = napi_create_typedarray(
+      env, type, length, output_buffer, byte_offset, &output_array);
+  if (status != napi_ok) return;
+
+  if (type == napi_uint8_array) {
+    uint8_t* input_bytes = (uint8_t*)(data) + byte_offset;
+    uint8_t* output_bytes = (uint8_t*)(output_ptr);
+    for (i = 0; i < length; i++) {
+      output_bytes[i] = (uint8_t)(input_bytes[i] * multiplier);
+    }
+  } else if (type == napi_float64_array) {
+    double* input_doubles = (double*)((uint8_t*)(data) + byte_offset);
+    double* output_doubles = (double*)(output_ptr);
+    for (i = 0; i < length; i++) {
+      output_doubles[i] = input_doubles[i] * multiplier;
+    }
+  } else {
+    napi_throw_error(env, "Typed array was of a type not expected by test.");
+    return;
+  }
+
+  status = napi_set_return_value(env, info, output_array);
+  if (status != napi_ok) return;
+}
+
+void External(napi_env env, napi_callback_info info) {
+  static int8_t externalData[] = {0, 1, 2};
+
+  napi_value output_buffer;
+  napi_status status = napi_create_external_arraybuffer(
+      env,
+      externalData,
+      sizeof(externalData),
+      NULL,  // finalize_callback
+      NULL,  // finalize_hint
+      &output_buffer);
+  if (status != napi_ok) return;
+
+  napi_value output_array;
+  status = napi_create_typedarray(env,
+                                  napi_int8_array,
+                                  sizeof(externalData) / sizeof(uint8_t),
+                                  output_buffer,
+                                  0,
+                                  &output_array);
+  if (status != napi_ok) return;
+
+  status = napi_set_return_value(env, info, output_array);
+  if (status != napi_ok) return;
+}
+
+#define DECLARE_NAPI_METHOD(name, func)                          \
+  { name, func, 0, 0, 0, napi_default, 0 }
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+
+  napi_property_descriptor descriptors[] = {
+      DECLARE_NAPI_METHOD("Multiply", Multiply),
+      DECLARE_NAPI_METHOD("External", External),
+  };
+
+  status = napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/testcfg.py b/test/addons-napi/testcfg.py
new file mode 100644
index 00000000000000..ef7c18fdae8572
--- /dev/null
+++ b/test/addons-napi/testcfg.py
@@ -0,0 +1,6 @@
+import sys, os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+import testpy
+
+def GetConfiguration(context, root):
+  return testpy.AddonTestConfiguration(context, root, 'addons-napi', ['--napi-modules'])
diff --git a/test/testpy/__init__.py b/test/testpy/__init__.py
index 4e6fb4e660d9d0..7502d990023451 100644
--- a/test/testpy/__init__.py
+++ b/test/testpy/__init__.py
@@ -149,5 +149,5 @@ def ListTests(self, current_path, path, arch, mode):
       if self.Contains(path, test):
         file_path = join(self.root, reduce(join, test[1:], "") + ".js")
         result.append(
-            SimpleTestCase(test, file_path, arch, mode, self.context, self))
+            SimpleTestCase(test, file_path, arch, mode, self.context, self, self.additional_flags))
     return result
diff --git a/tools/install.py b/tools/install.py
index 5abcde49c16a2d..bb7d52818892a5 100755
--- a/tools/install.py
+++ b/tools/install.py
@@ -154,6 +154,8 @@ def headers(action):
     'common.gypi',
     'config.gypi',
     'src/node.h',
+    'src/node_api.h',
+    'src/node_api_types.h',
     'src/node_buffer.h',
     'src/node_object_wrap.h',
     'src/node_version.h',
diff --git a/tools/test.py b/tools/test.py
index 561473f246629b..24a27ac18a95cc 100755
--- a/tools/test.py
+++ b/tools/test.py
@@ -1469,6 +1469,7 @@ def ExpandCommand(args):
   'message',
   'internet',
   'addons',
+  'addons-napi',
   'gc',
   'debugger',
   'doctool',
diff --git a/vcbuild.bat b/vcbuild.bat
index a46c99d75916e6..0f95fb3a2a2690 100644
--- a/vcbuild.bat
+++ b/vcbuild.bat
@@ -41,6 +41,7 @@ set configure_flags=
 set build_addons=
 set dll=
 set enable_static=
+set build_addons_napi=
 
 :next-arg
 if "%1"=="" goto args-done
@@ -58,9 +59,10 @@ if /i "%1"=="nosnapshot"    set nosnapshot=1&goto arg-ok
 if /i "%1"=="noetw"         set noetw=1&goto arg-ok
 if /i "%1"=="noperfctr"     set noperfctr=1&goto arg-ok
 if /i "%1"=="licensertf"    set licensertf=1&goto arg-ok
-if /i "%1"=="test"          set test_args=%test_args% abort doctool known_issues message parallel sequential addons -J&set lint_cpp=1&set lint_js=1&set build_addons=1&goto arg-ok
-if /i "%1"=="test-ci"       set test_args=%test_args% %test_ci_args% -p tap --logfile test.tap abort doctool inspector known_issues message sequential parallel addons&set cctest_args=%cctest_args% --gtest_output=tap:cctest.tap&set build_addons=1&goto arg-ok
+if /i "%1"=="test"          set test_args=%test_args% abort doctool known_issues message parallel sequential addons addons-napi -J&set lint_cpp=1&set lint_js=1&set build_addons=1&set build_addons_napi=1&goto arg-ok
+if /i "%1"=="test-ci"       set test_args=%test_args% %test_ci_args% -p tap --logfile test.tap abort doctool inspector known_issues message sequential parallel addons addons-napi &set cctest_args=%cctest_args% --gtest_output=tap:cctest.tap&set build_addons=1&set build_addons_napi=1&goto arg-ok
 if /i "%1"=="test-addons"   set test_args=%test_args% addons&set build_addons=1&goto arg-ok
+if /i "%1"=="test-addons-napi"   set test_args=%test_args% addons-napi&set build_addons_napi=1&goto arg-ok
 if /i "%1"=="test-simple"   set test_args=%test_args% sequential parallel -J&goto arg-ok
 if /i "%1"=="test-message"  set test_args=%test_args% message&goto arg-ok
 if /i "%1"=="test-gc"       set test_args=%test_args% gc&set buildnodeweak=1&goto arg-ok
@@ -318,12 +320,12 @@ echo Failed to build node-weak.
 goto exit
 
 :build-addons
-if not defined build_addons goto run-tests
+if not defined build_addons goto build-addons-napi
 if not exist "%node_exe%" (
   echo Failed to find node.exe
-  goto run-tests
+  goto build-addons-napi
 )
-echo Building add-ons
+echo Building addons
 :: clear
 for /d %%F in (test\addons\??_*) do (
   rd /s /q %%F
@@ -339,6 +341,24 @@ for /d %%F in (test\addons\*) do (
     --nodedir="%cd%"
   if !errorlevel! neq 0 exit /b !errorlevel!
 )
+
+:build-addons-napi
+if not defined build_addons_napi goto run-tests
+if not exist "%node_exe%" (
+  echo Failed to find node.exe
+  goto run-tests
+)
+echo Building addons-napi
+:: clear
+for /d %%F in (test\addons-napi\??_*) do (
+  rd /s /q %%F
+)
+:: building addons-napi
+for /d %%F in (test\addons-napi\*) do (
+  "%node_exe%" deps\npm\node_modules\node-gyp\bin\node-gyp rebuild ^
+    --directory="%%F" ^
+    --nodedir="%cd%"
+)
 endlocal
 goto run-tests
 

From 7a43dd2f429dea01610803608116433fbef0510d Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Mon, 3 Apr 2017 11:30:00 -0400
Subject: [PATCH 002/183] n-api: break dep between v8 and napi attributes

The v8 n-api implementation had been depending on a one-to-one
relationship between v8 and n-api v8 property attributes.
Remove this dependency and fix coverity scan issue
165845.

PR-URL: https://github.com/nodejs/node/pull/12191
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
---
 src/node_api.cc | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 8269941e6812cd..747c8c5bb9c435 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -26,6 +26,22 @@ napi_env JsEnvFromV8Isolate(v8::Isolate* isolate) {
   return reinterpret_cast<napi_env>(isolate);
 }
 
+// convert from n-api property attributes to v8::PropertyAttribute
+static inline v8::PropertyAttribute V8PropertyAttributesFromAttributes(
+    napi_property_attributes attributes) {
+  unsigned int attribute_flags = v8::None;
+  if (attributes & napi_read_only) {
+    attribute_flags |= v8::ReadOnly;
+  }
+  if (attributes & napi_dont_enum) {
+    attribute_flags |= v8::DontEnum;
+  }
+  if (attributes & napi_dont_delete) {
+    attribute_flags |= v8::DontDelete;
+  }
+  return static_cast<v8::PropertyAttribute>(attribute_flags);
+}
+
 v8::Isolate* V8IsolateFromJsEnv(napi_env e) {
   return reinterpret_cast<v8::Isolate*>(e);
 }
@@ -741,9 +757,8 @@ napi_status napi_define_class(napi_env env,
 
     v8::Local<v8::String> property_name;
     CHECK_NEW_FROM_UTF8(isolate, property_name, p->utf8name);
-
     v8::PropertyAttribute attributes =
-        static_cast<v8::PropertyAttribute>(p->attributes);
+        v8impl::V8PropertyAttributesFromAttributes(p->attributes);
 
     // This code is similar to that in napi_define_property(); the
     // difference is it applies to a template instead of an object.
@@ -1052,8 +1067,9 @@ napi_status napi_define_properties(napi_env env,
     v8::Local<v8::Name> name;
     CHECK_NEW_FROM_UTF8(isolate, name, p->utf8name);
 
-    v8::PropertyAttribute attributes = static_cast<v8::PropertyAttribute>(
-        p->attributes & ~napi_static_property);
+    v8::PropertyAttribute attributes =
+        v8impl::V8PropertyAttributesFromAttributes(
+            (napi_property_attributes)(p->attributes & ~napi_static_property));
 
     if (p->method) {
       v8::Local<v8::Object> cbdata =

From 62442248dcb4dcf33790c4ef92b70005e545f445 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Mon, 3 Apr 2017 12:34:34 -0400
Subject: [PATCH 003/183] napi: supress invalid coverity leak message

Coverity was complaining that finalizer was being
leaked in this method, however it should be
freed when the buffer is finalized so I believe
the message is invalid.

Add the required comments to suppress the warning.

PR-URL: https://github.com/nodejs/node/pull/12192
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Hitesh Kanwathirtha <hiteshk@microsoft.com>
---
 src/node_api.cc | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/node_api.cc b/src/node_api.cc
index 747c8c5bb9c435..e524b1cd4ed035 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -2291,6 +2291,10 @@ napi_status napi_create_external_buffer(napi_env env,
 
   *result = v8impl::JsValueFromV8LocalValue(maybe.ToLocalChecked());
   return GET_RETURN_STATUS();
+  // Tell coverity that 'finalizer' should not be freed when we return
+  // as it will be deleted when the buffer to which it is associated
+  // is finalized.
+  // coverity[leaked_storage]
 }
 
 napi_status napi_create_buffer_copy(napi_env env,

From 69fe5ae461d39a7a77e746e7de78403f6a4ca40b Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Wed, 29 Mar 2017 01:18:58 +0300
Subject: [PATCH 004/183] n-api: create napi_env as a real structure

1. We define struct napi_env__ to include the isolate, the last
exception, and the info about the last error.

2. We instantiate one struct napi_env__ during module registration and
we pass it into the FunctionCallbackInfo for all subsequent entries into
N-API when we create functions/accessors/finalizers.

Once module unloading will be supported we shall have to delete the
napi_env we create during module init.

There is a clear separation between public and private API wrt. env:

1. Public APIs assert that env is not nullptr as their first action.

2. Private APIs need not validate env. They assume it's not nullptr.

PR-URL: https://github.com/nodejs/node/pull/12195
Fixes: https://github.com/nodejs/abi-stable-node/issues/198
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 src/node_api.cc                               | 834 +++++++++---------
 test/addons-napi/test_napi_status/binding.gyp |   8 +
 test/addons-napi/test_napi_status/test.js     |   8 +
 .../test_napi_status/test_napi_status.cc      |  47 +
 4 files changed, 498 insertions(+), 399 deletions(-)
 create mode 100644 test/addons-napi/test_napi_status/binding.gyp
 create mode 100644 test/addons-napi/test_napi_status/test.js
 create mode 100644 test/addons-napi/test_napi_status/test_napi_status.cc

diff --git a/src/node_api.cc b/src/node_api.cc
index e524b1cd4ed035..5534f78893364c 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -8,7 +8,6 @@
  *
  ******************************************************************************/
 
-
 #include <node_buffer.h>
 #include <node_object_wrap.h>
 #include <string.h>
@@ -18,13 +17,24 @@
 #include "node_api.h"
 #include "node_api_backport.h"
 
-namespace v8impl {
+static
+napi_status napi_set_last_error(napi_env env, napi_status error_code,
+                                uint32_t engine_error_code = 0,
+                                void* engine_reserved = nullptr);
+void napi_clear_last_error(napi_env env);
 
-//=== Conversion between V8 Isolate and napi_env ==========================
+class napi_env__ {
+ public:
+  explicit napi_env__(v8::Isolate* _isolate): isolate(_isolate), last_error() {}
+  ~napi_env__() {
+    last_exception.Reset();
+  }
+  v8::Isolate* isolate;
+  v8::Persistent<v8::Value> last_exception;
+  napi_extended_error_info last_error;
+};
 
-napi_env JsEnvFromV8Isolate(v8::Isolate* isolate) {
-  return reinterpret_cast<napi_env>(isolate);
-}
+namespace v8impl {
 
 // convert from n-api property attributes to v8::PropertyAttribute
 static inline v8::PropertyAttribute V8PropertyAttributesFromAttributes(
@@ -110,11 +120,11 @@ v8::Local<v8::Value> V8LocalValueFromJsValue(napi_value v) {
 // Adapter for napi_finalize callbacks.
 class Finalizer {
  protected:
-  Finalizer(v8::Isolate* isolate,
+  Finalizer(napi_env env,
              napi_finalize finalize_callback,
              void* finalize_data,
              void* finalize_hint)
-    : _isolate(isolate),
+    : _env(env),
       _finalize_callback(finalize_callback),
       _finalize_data(finalize_data),
       _finalize_hint(finalize_hint) {
@@ -124,12 +134,12 @@ class Finalizer {
   }
 
  public:
-  static Finalizer* New(v8::Isolate* isolate,
+  static Finalizer* New(napi_env env,
                         napi_finalize finalize_callback = nullptr,
                         void* finalize_data = nullptr,
                         void* finalize_hint = nullptr) {
     return new Finalizer(
-      isolate, finalize_callback, finalize_data, finalize_hint);
+      env, finalize_callback, finalize_data, finalize_hint);
   }
 
   static void Delete(Finalizer* finalizer) {
@@ -141,7 +151,7 @@ class Finalizer {
     Finalizer* finalizer = static_cast<Finalizer*>(hint);
     if (finalizer->_finalize_callback != nullptr) {
       finalizer->_finalize_callback(
-        v8impl::JsEnvFromV8Isolate(finalizer->_isolate),
+        finalizer->_env,
         data,
         finalizer->_finalize_hint);
     }
@@ -150,7 +160,7 @@ class Finalizer {
   }
 
  protected:
-  v8::Isolate* _isolate;
+  napi_env _env;
   napi_finalize _finalize_callback;
   void* _finalize_data;
   void* _finalize_hint;
@@ -159,15 +169,15 @@ class Finalizer {
 // Wrapper around v8::Persistent that implements reference counting.
 class Reference : private Finalizer {
  private:
-  Reference(v8::Isolate* isolate,
+  Reference(napi_env env,
             v8::Local<v8::Value> value,
             uint32_t initial_refcount,
             bool delete_self,
             napi_finalize finalize_callback,
             void* finalize_data,
             void* finalize_hint)
-       : Finalizer(isolate, finalize_callback, finalize_data, finalize_hint),
-        _persistent(isolate, value),
+       : Finalizer(env, finalize_callback, finalize_data, finalize_hint),
+        _persistent(env->isolate, value),
         _refcount(initial_refcount),
         _delete_self(delete_self) {
     if (initial_refcount == 0) {
@@ -188,14 +198,14 @@ class Reference : private Finalizer {
   }
 
  public:
-  static Reference* New(v8::Isolate* isolate,
+  static Reference* New(napi_env env,
                         v8::Local<v8::Value> value,
                         uint32_t initial_refcount,
                         bool delete_self,
                         napi_finalize finalize_callback = nullptr,
                         void* finalize_data = nullptr,
                         void* finalize_hint = nullptr) {
-    return new Reference(isolate,
+    return new Reference(env,
       value,
       initial_refcount,
       delete_self,
@@ -237,7 +247,7 @@ class Reference : private Finalizer {
     if (_persistent.IsEmpty()) {
       return v8::Local<v8::Value>();
     } else {
-      return v8::Local<v8::Value>::New(_isolate, _persistent);
+      return v8::Local<v8::Value>::New(_env->isolate, _persistent);
     }
   }
 
@@ -252,7 +262,7 @@ class Reference : private Finalizer {
 
     if (reference->_finalize_callback != nullptr) {
       reference->_finalize_callback(
-          v8impl::JsEnvFromV8Isolate(reference->_isolate),
+          reference->_env,
           reference->_finalize_data,
           reference->_finalize_hint);
     }
@@ -269,34 +279,30 @@ class Reference : private Finalizer {
 
 class TryCatch : public v8::TryCatch {
  public:
-  explicit TryCatch(v8::Isolate* isolate)
-      : v8::TryCatch(isolate), _isolate(isolate) {}
+  explicit TryCatch(napi_env env)
+      : v8::TryCatch(env->isolate), _env(env) {}
 
   ~TryCatch() {
     if (HasCaught()) {
-      _the_exception.Reset(_isolate, Exception());
+      _env->last_exception.Reset(_env->isolate, Exception());
     }
   }
 
-  static v8::Persistent<v8::Value>& LastException() { return _the_exception; }
-
  private:
-  static v8::Persistent<v8::Value> _the_exception;
-  v8::Isolate* _isolate;
+  napi_env _env;
 };
 
-v8::Persistent<v8::Value> TryCatch::_the_exception;
-
 //=== Function napi_callback wrapper =================================
 
 static const int kDataIndex = 0;
+static const int kEnvIndex = 1;
 
-static const int kFunctionIndex = 1;
-static const int kFunctionFieldCount = 2;
+static const int kFunctionIndex = 2;
+static const int kFunctionFieldCount = 3;
 
-static const int kGetterIndex = 1;
-static const int kSetterIndex = 2;
-static const int kAccessorFieldCount = 3;
+static const int kGetterIndex = 2;
+static const int kSetterIndex = 3;
+static const int kAccessorFieldCount = 4;
 
 // Base class extended by classes that wrap V8 function and property callback
 // info.
@@ -345,12 +351,18 @@ class CallbackWrapperBase : public CallbackWrapper {
         v8::Local<v8::External>::Cast(
             _cbdata->GetInternalField(kInternalFieldIndex))->Value());
     v8::Isolate* isolate = _cbinfo.GetIsolate();
-    cb(v8impl::JsEnvFromV8Isolate(isolate), cbinfo_wrapper);
+    napi_env env = static_cast<napi_env>(
+        v8::Local<v8::External>::Cast(
+            _cbdata->GetInternalField(kEnvIndex))->Value());
+
+    // Make sure any errors encountered last time we were in N-API are gone.
+    napi_clear_last_error(env);
+    cb(env, cbinfo_wrapper);
 
-    if (!TryCatch::LastException().IsEmpty()) {
+    if (!env->last_exception.IsEmpty()) {
       isolate->ThrowException(
-          v8::Local<v8::Value>::New(isolate, TryCatch::LastException()));
-      TryCatch::LastException().Reset();
+          v8::Local<v8::Value>::New(isolate, env->last_exception));
+      env->last_exception.Reset();
     }
   }
 
@@ -475,13 +487,16 @@ class SetterCallbackWrapper
 v8::Local<v8::Object> CreateFunctionCallbackData(napi_env env,
                                                  napi_callback cb,
                                                  void* data) {
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
 
   v8::Local<v8::ObjectTemplate> otpl = v8::ObjectTemplate::New(isolate);
   otpl->SetInternalFieldCount(v8impl::kFunctionFieldCount);
   v8::Local<v8::Object> cbdata = otpl->NewInstance(context).ToLocalChecked();
 
+  cbdata->SetInternalField(
+      v8impl::kEnvIndex,
+      v8::External::New(isolate, static_cast<void*>(env)));
   cbdata->SetInternalField(
       v8impl::kFunctionIndex,
       v8::External::New(isolate, reinterpret_cast<void*>(cb)));
@@ -498,13 +513,17 @@ v8::Local<v8::Object> CreateAccessorCallbackData(napi_env env,
                                                  napi_callback getter,
                                                  napi_callback setter,
                                                  void* data) {
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
 
   v8::Local<v8::ObjectTemplate> otpl = v8::ObjectTemplate::New(isolate);
   otpl->SetInternalFieldCount(v8impl::kAccessorFieldCount);
   v8::Local<v8::Object> cbdata = otpl->NewInstance(context).ToLocalChecked();
 
+  cbdata->SetInternalField(
+      v8impl::kEnvIndex,
+      v8::External::New(isolate, static_cast<void*>(env)));
+
   if (getter != nullptr) {
     cbdata->SetInternalField(
         v8impl::kGetterIndex,
@@ -533,8 +552,13 @@ void napi_module_register_cb(v8::Local<v8::Object> exports,
                              v8::Local<v8::Context> context,
                              void* priv) {
   napi_module* mod = static_cast<napi_module*>(priv);
+
+  // Create a new napi_env for this module. Once module unloading is supported
+  // we shall have to call delete on this object from there.
+  napi_env env = new napi_env__(context->GetIsolate());
+
   mod->nm_register_func(
-    v8impl::JsEnvFromV8Isolate(context->GetIsolate()),
+    env,
     v8impl::JsValueFromV8LocalValue(exports),
     v8impl::JsValueFromV8LocalValue(module),
     mod->nm_priv);
@@ -574,65 +598,69 @@ void napi_module_register(napi_module* mod) {
   node::node_module_register(nm);
 }
 
-#define RETURN_STATUS_IF_FALSE(condition, status)                       \
+#define RETURN_STATUS_IF_FALSE(env, condition, status)                  \
   do {                                                                  \
     if (!(condition)) {                                                 \
-      return napi_set_last_error((status));                             \
+      return napi_set_last_error((env), (status));                      \
     }                                                                   \
   } while (0)
 
-#define CHECK_ARG(arg) RETURN_STATUS_IF_FALSE((arg), napi_invalid_arg)
+#define CHECK_ENV(env)                                               \
+  if ((env) == nullptr) {                                            \
+    node::FatalError(__func__, "environment(env) must not be null"); \
+  }
 
-#define CHECK_MAYBE_EMPTY(maybe, status) \
-  RETURN_STATUS_IF_FALSE(!((maybe).IsEmpty()), (status))
+#define CHECK_ARG(env, arg) \
+  RETURN_STATUS_IF_FALSE((env), ((arg) != nullptr), napi_invalid_arg)
 
-#define CHECK_MAYBE_NOTHING(maybe, status) \
-  RETURN_STATUS_IF_FALSE(!((maybe).IsNothing()), (status))
+#define CHECK_MAYBE_EMPTY(env, maybe, status) \
+  RETURN_STATUS_IF_FALSE((env), !((maybe).IsEmpty()), (status))
+
+#define CHECK_MAYBE_NOTHING(env, maybe, status) \
+  RETURN_STATUS_IF_FALSE((env), !((maybe).IsNothing()), (status))
 
 // NAPI_PREAMBLE is not wrapped in do..while: try_catch must have function scope
-#define NAPI_PREAMBLE(env)                                            \
-  CHECK_ARG(env);                                                     \
-  RETURN_STATUS_IF_FALSE(v8impl::TryCatch::LastException().IsEmpty(), \
-                         napi_pending_exception);                     \
-  napi_clear_last_error();                                            \
-  v8impl::TryCatch try_catch(v8impl::V8IsolateFromJsEnv((env)))
-
-#define CHECK_TO_TYPE(type, context, result, src, status)                     \
+#define NAPI_PREAMBLE(env)                                       \
+  CHECK_ENV((env));                                              \
+  RETURN_STATUS_IF_FALSE((env), (env)->last_exception.IsEmpty(), \
+                         napi_pending_exception);                \
+  napi_clear_last_error((env));                                  \
+  v8impl::TryCatch try_catch((env))
+
+#define CHECK_TO_TYPE(env, type, context, result, src, status)                \
   do {                                                                        \
     auto maybe = v8impl::V8LocalValueFromJsValue((src))->To##type((context)); \
-    CHECK_MAYBE_EMPTY(maybe, (status));                                       \
-    result = maybe.ToLocalChecked();                                          \
+    CHECK_MAYBE_EMPTY((env), maybe, (status));                                \
+    (result) = maybe.ToLocalChecked();                                        \
   } while (0)
 
-#define CHECK_TO_OBJECT(context, result, src) \
-  CHECK_TO_TYPE(Object, context, result, src, napi_object_expected)
+#define CHECK_TO_OBJECT(env, context, result, src) \
+  CHECK_TO_TYPE((env), Object, (context), (result), (src), napi_object_expected)
 
-#define CHECK_TO_STRING(context, result, src) \
-  CHECK_TO_TYPE(String, context, result, src, napi_string_expected)
+#define CHECK_TO_STRING(env, context, result, src) \
+  CHECK_TO_TYPE((env), String, (context), (result), (src), napi_string_expected)
 
-#define CHECK_TO_NUMBER(context, result, src) \
-  CHECK_TO_TYPE(Number, context, result, src, napi_number_expected)
+#define CHECK_TO_NUMBER(env, context, result, src) \
+  CHECK_TO_TYPE((env), Number, (context), (result), (src), napi_number_expected)
 
-#define CHECK_TO_BOOL(context, result, src) \
-  CHECK_TO_TYPE(Boolean, context, result, src, napi_boolean_expected)
+#define CHECK_TO_BOOL(env, context, result, src)            \
+  CHECK_TO_TYPE((env), Boolean, (context), (result), (src), \
+    napi_boolean_expected)
 
-#define CHECK_NEW_FROM_UTF8_LEN(isolate, result, str, len)          \
-  do {                                                              \
-    auto str_maybe = v8::String::NewFromUtf8(                       \
-        (isolate), (str), v8::NewStringType::kInternalized, (len)); \
-    CHECK_MAYBE_EMPTY(str_maybe, napi_generic_failure);             \
-    result = str_maybe.ToLocalChecked();                            \
+#define CHECK_NEW_FROM_UTF8_LEN(env, result, str, len)                   \
+  do {                                                                   \
+    auto str_maybe = v8::String::NewFromUtf8(                            \
+        (env)->isolate, (str), v8::NewStringType::kInternalized, (len)); \
+    CHECK_MAYBE_EMPTY((env), str_maybe, napi_generic_failure);           \
+    result = str_maybe.ToLocalChecked();                                 \
   } while (0)
 
-#define CHECK_NEW_FROM_UTF8(isolate, result, str) \
-  CHECK_NEW_FROM_UTF8_LEN((isolate), (result), (str), -1)
+#define CHECK_NEW_FROM_UTF8(env, result, str) \
+  CHECK_NEW_FROM_UTF8_LEN((env), (result), (str), -1)
 
-#define GET_RETURN_STATUS()        \
+#define GET_RETURN_STATUS(env)      \
   (!try_catch.HasCaught() ? napi_ok \
-                         : napi_set_last_error(napi_pending_exception))
-
-// Static last error returned from napi_get_last_error_info
-napi_extended_error_info static_last_error = { nullptr, nullptr, 0, napi_ok };
+                         : napi_set_last_error((env), napi_pending_exception))
 
 // Warning: Keep in-sync with napi_status enum
 const char* error_messages[] = {nullptr,
@@ -646,38 +674,38 @@ const char* error_messages[] = {nullptr,
                                 "Unknown failure",
                                 "An exception is pending"};
 
-void napi_clear_last_error() {
-  static_last_error.error_code = napi_ok;
+void napi_clear_last_error(napi_env env) {
+  env->last_error.error_code = napi_ok;
 
   // TODO(boingoing): Should this be a callback?
-  static_last_error.engine_error_code = 0;
-  static_last_error.engine_reserved = nullptr;
+  env->last_error.engine_error_code = 0;
+  env->last_error.engine_reserved = nullptr;
 }
 
-napi_status napi_set_last_error(napi_status error_code,
-                                uint32_t engine_error_code = 0,
-                                void* engine_reserved = nullptr) {
-  static_last_error.error_code = error_code;
-  static_last_error.engine_error_code = engine_error_code;
-  static_last_error.engine_reserved = engine_reserved;
+napi_status napi_set_last_error(napi_env env, napi_status error_code,
+                                uint32_t engine_error_code,
+                                void* engine_reserved) {
+  env->last_error.error_code = error_code;
+  env->last_error.engine_error_code = engine_error_code;
+  env->last_error.engine_reserved = engine_reserved;
 
   return error_code;
 }
 
 napi_status napi_get_last_error_info(napi_env env,
                                      const napi_extended_error_info** result) {
-  CHECK_ARG(env);
+  CHECK_ENV(env);
 
   static_assert(node::arraysize(error_messages) == napi_status_last,
       "Count of error messages must match count of error values");
-  assert(static_last_error.error_code < napi_status_last);
+  assert(env->last_error.error_code < napi_status_last);
 
   // Wait until someone requests the last error information to fetch the error
   // message string
-  static_last_error.error_message =
-      error_messages[static_last_error.error_code];
+  env->last_error.error_message =
+      error_messages[env->last_error.error_code];
 
-  *result = &static_last_error;
+  *result = &(env->last_error);
   return napi_ok;
 }
 
@@ -687,34 +715,34 @@ napi_status napi_create_function(napi_env env,
                                  void* callback_data,
                                  napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Function> return_value;
   v8::EscapableHandleScope scope(isolate);
   v8::Local<v8::Object> cbdata =
       v8impl::CreateFunctionCallbackData(env, cb, callback_data);
 
-  RETURN_STATUS_IF_FALSE(!cbdata.IsEmpty(), napi_generic_failure);
+  RETURN_STATUS_IF_FALSE(env, !cbdata.IsEmpty(), napi_generic_failure);
 
   v8::Local<v8::FunctionTemplate> tpl = v8::FunctionTemplate::New(
       isolate, v8impl::FunctionCallbackWrapper::Invoke, cbdata);
 
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::MaybeLocal<v8::Function> maybe_function = tpl->GetFunction(context);
-  CHECK_MAYBE_EMPTY(maybe_function, napi_generic_failure);
+  CHECK_MAYBE_EMPTY(env, maybe_function, napi_generic_failure);
 
   return_value = scope.Escape(maybe_function.ToLocalChecked());
 
   if (utf8name != nullptr) {
     v8::Local<v8::String> name_string;
-    CHECK_NEW_FROM_UTF8(isolate, name_string, utf8name);
+    CHECK_NEW_FROM_UTF8(env, name_string, utf8name);
     return_value->SetName(name_string);
   }
 
   *result = v8impl::JsValueFromV8LocalValue(return_value);
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_define_class(napi_env env,
@@ -725,15 +753,15 @@ napi_status napi_define_class(napi_env env,
                               const napi_property_descriptor* properties,
                               napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
 
   v8::EscapableHandleScope scope(isolate);
   v8::Local<v8::Object> cbdata =
       v8impl::CreateFunctionCallbackData(env, constructor, callback_data);
 
-  RETURN_STATUS_IF_FALSE(!cbdata.IsEmpty(), napi_generic_failure);
+  RETURN_STATUS_IF_FALSE(env, !cbdata.IsEmpty(), napi_generic_failure);
 
   v8::Local<v8::FunctionTemplate> tpl = v8::FunctionTemplate::New(
       isolate, v8impl::FunctionCallbackWrapper::Invoke, cbdata);
@@ -742,7 +770,7 @@ napi_status napi_define_class(napi_env env,
   tpl->InstanceTemplate()->SetInternalFieldCount(1);
 
   v8::Local<v8::String> name_string;
-  CHECK_NEW_FROM_UTF8(isolate, name_string, utf8name);
+  CHECK_NEW_FROM_UTF8(env, name_string, utf8name);
   tpl->SetClassName(name_string);
 
   size_t static_property_count = 0;
@@ -756,7 +784,7 @@ napi_status napi_define_class(napi_env env,
     }
 
     v8::Local<v8::String> property_name;
-    CHECK_NEW_FROM_UTF8(isolate, property_name, p->utf8name);
+    CHECK_NEW_FROM_UTF8(env, property_name, p->utf8name);
     v8::PropertyAttribute attributes =
         v8impl::V8PropertyAttributesFromAttributes(p->attributes);
 
@@ -766,7 +794,7 @@ napi_status napi_define_class(napi_env env,
       v8::Local<v8::Object> cbdata =
           v8impl::CreateFunctionCallbackData(env, p->method, p->data);
 
-      RETURN_STATUS_IF_FALSE(!cbdata.IsEmpty(), napi_generic_failure);
+      RETURN_STATUS_IF_FALSE(env, !cbdata.IsEmpty(), napi_generic_failure);
 
       v8::Local<v8::FunctionTemplate> t =
           v8::FunctionTemplate::New(isolate,
@@ -814,7 +842,7 @@ napi_status napi_define_class(napi_env env,
     if (status != napi_ok) return status;
   }
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_set_return_value(napi_env env,
@@ -826,27 +854,27 @@ napi_status napi_set_return_value(napi_env env,
       reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
 
   info->SetReturnValue(value);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_get_property_names(napi_env env,
                                     napi_value object,
                                     napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Object> obj;
-  CHECK_TO_OBJECT(context, obj, object);
+  CHECK_TO_OBJECT(env, context, obj, object);
 
   auto maybe_propertynames = obj->GetPropertyNames(context);
 
-  CHECK_MAYBE_EMPTY(maybe_propertynames, napi_generic_failure);
+  CHECK_MAYBE_EMPTY(env, maybe_propertynames, napi_generic_failure);
 
   *result = v8impl::JsValueFromV8LocalValue(
       maybe_propertynames.ToLocalChecked());
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_set_property(napi_env env,
@@ -855,19 +883,19 @@ napi_status napi_set_property(napi_env env,
                               napi_value value) {
   NAPI_PREAMBLE(env);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Object> obj;
 
-  CHECK_TO_OBJECT(context, obj, object);
+  CHECK_TO_OBJECT(env, context, obj, object);
 
   v8::Local<v8::Value> k = v8impl::V8LocalValueFromJsValue(key);
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
 
   v8::Maybe<bool> set_maybe = obj->Set(context, k, val);
 
-  RETURN_STATUS_IF_FALSE(set_maybe.FromMaybe(false), napi_generic_failure);
-  return GET_RETURN_STATUS();
+  RETURN_STATUS_IF_FALSE(env, set_maybe.FromMaybe(false), napi_generic_failure);
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_has_property(napi_env env,
@@ -875,21 +903,21 @@ napi_status napi_has_property(napi_env env,
                               napi_value key,
                               bool* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Object> obj;
 
-  CHECK_TO_OBJECT(context, obj, object);
+  CHECK_TO_OBJECT(env, context, obj, object);
 
   v8::Local<v8::Value> k = v8impl::V8LocalValueFromJsValue(key);
   v8::Maybe<bool> has_maybe = obj->Has(context, k);
 
-  CHECK_MAYBE_NOTHING(has_maybe, napi_generic_failure);
+  CHECK_MAYBE_NOTHING(env, has_maybe, napi_generic_failure);
 
   *result = has_maybe.FromMaybe(false);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_get_property(napi_env env,
@@ -897,22 +925,22 @@ napi_status napi_get_property(napi_env env,
                               napi_value key,
                               napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Value> k = v8impl::V8LocalValueFromJsValue(key);
   v8::Local<v8::Object> obj;
 
-  CHECK_TO_OBJECT(context, obj, object);
+  CHECK_TO_OBJECT(env, context, obj, object);
 
   auto get_maybe = obj->Get(context, k);
 
-  CHECK_MAYBE_EMPTY(get_maybe, napi_generic_failure);
+  CHECK_MAYBE_EMPTY(env, get_maybe, napi_generic_failure);
 
   v8::Local<v8::Value> val = get_maybe.ToLocalChecked();
   *result = v8impl::JsValueFromV8LocalValue(val);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_set_named_property(napi_env env,
@@ -921,21 +949,21 @@ napi_status napi_set_named_property(napi_env env,
                                     napi_value value) {
   NAPI_PREAMBLE(env);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Object> obj;
 
-  CHECK_TO_OBJECT(context, obj, object);
+  CHECK_TO_OBJECT(env, context, obj, object);
 
   v8::Local<v8::Name> key;
-  CHECK_NEW_FROM_UTF8(isolate, key, utf8name);
+  CHECK_NEW_FROM_UTF8(env, key, utf8name);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
 
   v8::Maybe<bool> set_maybe = obj->Set(context, key, val);
 
-  RETURN_STATUS_IF_FALSE(set_maybe.FromMaybe(false), napi_generic_failure);
-  return GET_RETURN_STATUS();
+  RETURN_STATUS_IF_FALSE(env, set_maybe.FromMaybe(false), napi_generic_failure);
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_has_named_property(napi_env env,
@@ -943,23 +971,23 @@ napi_status napi_has_named_property(napi_env env,
                                     const char* utf8name,
                                     bool* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Object> obj;
 
-  CHECK_TO_OBJECT(context, obj, object);
+  CHECK_TO_OBJECT(env, context, obj, object);
 
   v8::Local<v8::Name> key;
-  CHECK_NEW_FROM_UTF8(isolate, key, utf8name);
+  CHECK_NEW_FROM_UTF8(env, key, utf8name);
 
   v8::Maybe<bool> has_maybe = obj->Has(context, key);
 
-  CHECK_MAYBE_NOTHING(has_maybe, napi_generic_failure);
+  CHECK_MAYBE_NOTHING(env, has_maybe, napi_generic_failure);
 
   *result = has_maybe.FromMaybe(false);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_get_named_property(napi_env env,
@@ -967,25 +995,25 @@ napi_status napi_get_named_property(napi_env env,
                                     const char* utf8name,
                                     napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
 
   v8::Local<v8::Name> key;
-  CHECK_NEW_FROM_UTF8(isolate, key, utf8name);
+  CHECK_NEW_FROM_UTF8(env, key, utf8name);
 
   v8::Local<v8::Object> obj;
 
-  CHECK_TO_OBJECT(context, obj, object);
+  CHECK_TO_OBJECT(env, context, obj, object);
 
   auto get_maybe = obj->Get(context, key);
 
-  CHECK_MAYBE_EMPTY(get_maybe, napi_generic_failure);
+  CHECK_MAYBE_EMPTY(env, get_maybe, napi_generic_failure);
 
   v8::Local<v8::Value> val = get_maybe.ToLocalChecked();
   *result = v8impl::JsValueFromV8LocalValue(val);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_set_element(napi_env env,
@@ -994,18 +1022,18 @@ napi_status napi_set_element(napi_env env,
                              napi_value value) {
   NAPI_PREAMBLE(env);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Object> obj;
 
-  CHECK_TO_OBJECT(context, obj, object);
+  CHECK_TO_OBJECT(env, context, obj, object);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
   auto set_maybe = obj->Set(context, index, val);
 
-  RETURN_STATUS_IF_FALSE(set_maybe.FromMaybe(false), napi_generic_failure);
+  RETURN_STATUS_IF_FALSE(env, set_maybe.FromMaybe(false), napi_generic_failure);
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_has_element(napi_env env,
@@ -1013,20 +1041,20 @@ napi_status napi_has_element(napi_env env,
                              uint32_t index,
                              bool* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Object> obj;
 
-  CHECK_TO_OBJECT(context, obj, object);
+  CHECK_TO_OBJECT(env, context, obj, object);
 
   v8::Maybe<bool> has_maybe = obj->Has(context, index);
 
-  CHECK_MAYBE_NOTHING(has_maybe, napi_generic_failure);
+  CHECK_MAYBE_NOTHING(env, has_maybe, napi_generic_failure);
 
   *result = has_maybe.FromMaybe(false);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_get_element(napi_env env,
@@ -1034,20 +1062,20 @@ napi_status napi_get_element(napi_env env,
                              uint32_t index,
                              napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Object> obj;
 
-  CHECK_TO_OBJECT(context, obj, object);
+  CHECK_TO_OBJECT(env, context, obj, object);
 
   auto get_maybe = obj->Get(context, index);
 
-  CHECK_MAYBE_EMPTY(get_maybe, napi_generic_failure);
+  CHECK_MAYBE_EMPTY(env, get_maybe, napi_generic_failure);
 
   *result = v8impl::JsValueFromV8LocalValue(get_maybe.ToLocalChecked());
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_define_properties(napi_env env,
@@ -1056,7 +1084,7 @@ napi_status napi_define_properties(napi_env env,
                                    const napi_property_descriptor* properties) {
   NAPI_PREAMBLE(env);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Object> obj =
       v8impl::V8LocalValueFromJsValue(object).As<v8::Object>();
@@ -1065,7 +1093,7 @@ napi_status napi_define_properties(napi_env env,
     const napi_property_descriptor* p = &properties[i];
 
     v8::Local<v8::Name> name;
-    CHECK_NEW_FROM_UTF8(isolate, name, p->utf8name);
+    CHECK_NEW_FROM_UTF8(env, name, p->utf8name);
 
     v8::PropertyAttribute attributes =
         v8impl::V8PropertyAttributesFromAttributes(
@@ -1075,7 +1103,7 @@ napi_status napi_define_properties(napi_env env,
       v8::Local<v8::Object> cbdata =
           v8impl::CreateFunctionCallbackData(env, p->method, p->data);
 
-      RETURN_STATUS_IF_FALSE(!cbdata.IsEmpty(), napi_generic_failure);
+      RETURN_STATUS_IF_FALSE(env, !cbdata.IsEmpty(), napi_generic_failure);
 
       v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(
           isolate, v8impl::FunctionCallbackWrapper::Invoke, cbdata);
@@ -1084,7 +1112,7 @@ napi_status napi_define_properties(napi_env env,
           obj->DefineOwnProperty(context, name, t->GetFunction(), attributes);
 
       if (!define_maybe.FromMaybe(false)) {
-        return napi_set_last_error(napi_generic_failure);
+        return napi_set_last_error(env, napi_generic_failure);
       }
     } else if (p->getter || p->setter) {
       v8::Local<v8::Object> cbdata = v8impl::CreateAccessorCallbackData(
@@ -1103,7 +1131,7 @@ napi_status napi_define_properties(napi_env env,
           attributes);
 
       if (!set_maybe.FromMaybe(false)) {
-        return napi_set_last_error(napi_invalid_arg);
+        return napi_set_last_error(env, napi_invalid_arg);
       }
     } else {
       v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(p->value);
@@ -1112,37 +1140,37 @@ napi_status napi_define_properties(napi_env env,
           obj->DefineOwnProperty(context, name, value, attributes);
 
       if (!define_maybe.FromMaybe(false)) {
-        return napi_set_last_error(napi_invalid_arg);
+        return napi_set_last_error(env, napi_invalid_arg);
       }
     }
   }
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_is_array(napi_env env, napi_value value, bool* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
 
   *result = val->IsArray();
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_get_array_length(napi_env env,
                                   napi_value value,
                                   uint32_t* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
-  RETURN_STATUS_IF_FALSE(val->IsArray(), napi_array_expected);
+  RETURN_STATUS_IF_FALSE(env, val->IsArray(), napi_array_expected);
 
   v8::Local<v8::Array> arr = val.As<v8::Array>();
   *result = arr->Length();
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_strict_equals(napi_env env,
@@ -1150,62 +1178,62 @@ napi_status napi_strict_equals(napi_env env,
                                napi_value rhs,
                                bool* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> a = v8impl::V8LocalValueFromJsValue(lhs);
   v8::Local<v8::Value> b = v8impl::V8LocalValueFromJsValue(rhs);
 
   *result = a->StrictEquals(b);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_get_prototype(napi_env env,
                                napi_value object,
                                napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
 
   v8::Local<v8::Object> obj;
-  CHECK_TO_OBJECT(context, obj, object);
+  CHECK_TO_OBJECT(env, context, obj, object);
 
   v8::Local<v8::Value> val = obj->GetPrototype();
   *result = v8impl::JsValueFromV8LocalValue(val);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_create_object(napi_env env, napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   *result = v8impl::JsValueFromV8LocalValue(
-      v8::Object::New(v8impl::V8IsolateFromJsEnv(env)));
+      v8::Object::New(env->isolate));
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_create_array(napi_env env, napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   *result = v8impl::JsValueFromV8LocalValue(
-      v8::Array::New(v8impl::V8IsolateFromJsEnv(env)));
+      v8::Array::New(env->isolate));
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_create_array_with_length(napi_env env,
                                           size_t length,
                                           napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   *result = v8impl::JsValueFromV8LocalValue(
-      v8::Array::New(v8impl::V8IsolateFromJsEnv(env), length));
+      v8::Array::New(env->isolate, length));
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_create_string_utf8(napi_env env,
@@ -1213,14 +1241,13 @@ napi_status napi_create_string_utf8(napi_env env,
                                     size_t length,
                                     napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  auto isolate = v8impl::V8IsolateFromJsEnv(env);
   v8::Local<v8::String> s;
-  CHECK_NEW_FROM_UTF8_LEN(isolate, s, str, length);
+  CHECK_NEW_FROM_UTF8_LEN(env, s, str, length);
 
   *result = v8impl::JsValueFromV8LocalValue(s);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_create_string_utf16(napi_env env,
@@ -1228,37 +1255,37 @@ napi_status napi_create_string_utf16(napi_env env,
                                      size_t length,
                                      napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  auto isolate = v8impl::V8IsolateFromJsEnv(env);
+  auto isolate = env->isolate;
   auto str_maybe =
       v8::String::NewFromTwoByte(isolate,
                                  reinterpret_cast<const uint16_t*>(str),
                                  v8::NewStringType::kInternalized,
                                  length);
-  CHECK_MAYBE_EMPTY(str_maybe, napi_generic_failure);
+  CHECK_MAYBE_EMPTY(env, str_maybe, napi_generic_failure);
 
   *result = v8impl::JsValueFromV8LocalValue(str_maybe.ToLocalChecked());
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_create_number(napi_env env,
                                double value,
                                napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   *result = v8impl::JsValueFromV8LocalValue(
-      v8::Number::New(v8impl::V8IsolateFromJsEnv(env), value));
+      v8::Number::New(env->isolate, value));
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_get_boolean(napi_env env, bool value, napi_value* result) {
-  CHECK_ARG(env);
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
 
   if (value) {
     *result = v8impl::JsValueFromV8LocalValue(v8::True(isolate));
@@ -1273,66 +1300,66 @@ napi_status napi_create_symbol(napi_env env,
                                napi_value description,
                                napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
 
   if (description == nullptr) {
     *result = v8impl::JsValueFromV8LocalValue(v8::Symbol::New(isolate));
   } else {
     v8::Local<v8::Value> desc = v8impl::V8LocalValueFromJsValue(description);
-    RETURN_STATUS_IF_FALSE(desc->IsString(), napi_string_expected);
+    RETURN_STATUS_IF_FALSE(env, desc->IsString(), napi_string_expected);
 
     *result = v8impl::JsValueFromV8LocalValue(
       v8::Symbol::New(isolate, desc.As<v8::String>()));
   }
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_create_error(napi_env env,
                               napi_value msg,
                               napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> message_value = v8impl::V8LocalValueFromJsValue(msg);
-  RETURN_STATUS_IF_FALSE(message_value->IsString(), napi_string_expected);
+  RETURN_STATUS_IF_FALSE(env, message_value->IsString(), napi_string_expected);
 
   *result = v8impl::JsValueFromV8LocalValue(v8::Exception::Error(
       message_value.As<v8::String>()));
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_create_type_error(napi_env env,
                                    napi_value msg,
                                    napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> message_value = v8impl::V8LocalValueFromJsValue(msg);
-  RETURN_STATUS_IF_FALSE(message_value->IsString(), napi_string_expected);
+  RETURN_STATUS_IF_FALSE(env, message_value->IsString(), napi_string_expected);
 
   *result = v8impl::JsValueFromV8LocalValue(v8::Exception::TypeError(
       message_value.As<v8::String>()));
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_create_range_error(napi_env env,
                                     napi_value msg,
                                     napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> message_value = v8impl::V8LocalValueFromJsValue(msg);
-  RETURN_STATUS_IF_FALSE(message_value->IsString(), napi_string_expected);
+  RETURN_STATUS_IF_FALSE(env, message_value->IsString(), napi_string_expected);
 
   *result = v8impl::JsValueFromV8LocalValue(v8::Exception::RangeError(
       message_value.As<v8::String>()));
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_typeof(napi_env env,
@@ -1340,7 +1367,8 @@ napi_status napi_typeof(napi_env env,
                         napi_valuetype* result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
   // JS exceptions.
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> v = v8impl::V8LocalValueFromJsValue(value);
 
@@ -1366,28 +1394,28 @@ napi_status napi_typeof(napi_env env,
     *result = napi_external;
   } else {
     // Should not get here unless V8 has added some new kind of value.
-    return napi_set_last_error(napi_invalid_arg);
+    return napi_set_last_error(env, napi_invalid_arg);
   }
 
   return napi_ok;
 }
 
 napi_status napi_get_undefined(napi_env env, napi_value* result) {
-  CHECK_ARG(env);
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
 
   *result = v8impl::JsValueFromV8LocalValue(
-      v8::Undefined(v8impl::V8IsolateFromJsEnv(env)));
+      v8::Undefined(env->isolate));
 
   return napi_ok;
 }
 
 napi_status napi_get_null(napi_env env, napi_value* result) {
-  CHECK_ARG(env);
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
 
   *result = v8impl::JsValueFromV8LocalValue(
-        v8::Null(v8impl::V8IsolateFromJsEnv(env)));
+        v8::Null(env->isolate));
 
   return napi_ok;
 }
@@ -1401,10 +1429,11 @@ napi_status napi_get_cb_info(
     napi_value* argv,  // [out] Array of values
     napi_value* this_arg,  // [out] Receives the JS 'this' arg for the call
     void** data) {         // [out] Receives the data pointer for the callback.
-  CHECK_ARG(argc);
-  CHECK_ARG(argv);
-  CHECK_ARG(this_arg);
-  CHECK_ARG(data);
+  CHECK_ENV(env);
+  CHECK_ARG(env, argc);
+  CHECK_ARG(env, argv);
+  CHECK_ARG(env, this_arg);
+  CHECK_ARG(env, data);
 
   v8impl::CallbackWrapper* info =
       reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
@@ -1421,7 +1450,8 @@ napi_status napi_get_cb_args_length(napi_env env,
                                     napi_callback_info cbinfo,
                                     size_t* result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because no V8 APIs are called.
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
 
   v8impl::CallbackWrapper* info =
       reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
@@ -1434,7 +1464,8 @@ napi_status napi_is_construct_call(napi_env env,
                                    napi_callback_info cbinfo,
                                    bool* result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because no V8 APIs are called.
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
 
   v8impl::CallbackWrapper* info =
       reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
@@ -1450,7 +1481,8 @@ napi_status napi_get_cb_args(napi_env env,
                              napi_value* buf,
                              size_t bufsize) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because no V8 APIs are called.
-  CHECK_ARG(buf);
+  CHECK_ENV(env);
+  CHECK_ARG(env, buf);
 
   v8impl::CallbackWrapper* info =
       reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
@@ -1463,7 +1495,8 @@ napi_status napi_get_cb_this(napi_env env,
                              napi_callback_info cbinfo,
                              napi_value* result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because no V8 APIs are called.
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
 
   v8impl::CallbackWrapper* info =
       reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
@@ -1476,7 +1509,8 @@ napi_status napi_get_cb_data(napi_env env,
                              napi_callback_info cbinfo,
                              void** result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because no V8 APIs are called.
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
 
   v8impl::CallbackWrapper* info =
       reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
@@ -1493,23 +1527,23 @@ napi_status napi_call_function(napi_env env,
                                napi_value* result) {
   NAPI_PREAMBLE(env);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
 
   v8::Local<v8::Value> v8recv = v8impl::V8LocalValueFromJsValue(recv);
 
   v8::Local<v8::Value> v8value = v8impl::V8LocalValueFromJsValue(func);
-  RETURN_STATUS_IF_FALSE(v8value->IsFunction(), napi_invalid_arg);
+  RETURN_STATUS_IF_FALSE(env, v8value->IsFunction(), napi_invalid_arg);
 
   v8::Local<v8::Function> v8func = v8value.As<v8::Function>();
   auto maybe = v8func->Call(context, v8recv, argc,
     reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(argv)));
 
   if (try_catch.HasCaught()) {
-    return napi_set_last_error(napi_pending_exception);
+    return napi_set_last_error(env, napi_pending_exception);
   } else {
     if (result != nullptr) {
-      CHECK_MAYBE_EMPTY(maybe, napi_generic_failure);
+      CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure);
       *result = v8impl::JsValueFromV8LocalValue(maybe.ToLocalChecked());
     }
     return napi_ok;
@@ -1517,10 +1551,10 @@ napi_status napi_call_function(napi_env env,
 }
 
 napi_status napi_get_global(napi_env env, napi_value* result) {
-  CHECK_ARG(env);
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   // TODO(ianhall): what if we need the global object from a different
   // context in the same isolate?
   // Should napi_env be the current context rather than the current isolate?
@@ -1533,7 +1567,7 @@ napi_status napi_get_global(napi_env env, napi_value* result) {
 napi_status napi_throw(napi_env env, napi_value error) {
   NAPI_PREAMBLE(env);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
 
   isolate->ThrowException(v8impl::V8LocalValueFromJsValue(error));
   // any VM calls after this point and before returning
@@ -1544,9 +1578,9 @@ napi_status napi_throw(napi_env env, napi_value error) {
 napi_status napi_throw_error(napi_env env, const char* msg) {
   NAPI_PREAMBLE(env);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::String> str;
-  CHECK_NEW_FROM_UTF8(isolate, str, msg);
+  CHECK_NEW_FROM_UTF8(env, str, msg);
 
   isolate->ThrowException(v8::Exception::Error(str));
   // any VM calls after this point and before returning
@@ -1557,9 +1591,9 @@ napi_status napi_throw_error(napi_env env, const char* msg) {
 napi_status napi_throw_type_error(napi_env env, const char* msg) {
   NAPI_PREAMBLE(env);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::String> str;
-  CHECK_NEW_FROM_UTF8(isolate, str, msg);
+  CHECK_NEW_FROM_UTF8(env, str, msg);
 
   isolate->ThrowException(v8::Exception::TypeError(str));
   // any VM calls after this point and before returning
@@ -1570,9 +1604,9 @@ napi_status napi_throw_type_error(napi_env env, const char* msg) {
 napi_status napi_throw_range_error(napi_env env, const char* msg) {
   NAPI_PREAMBLE(env);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::String> str;
-  CHECK_NEW_FROM_UTF8(isolate, str, msg);
+  CHECK_NEW_FROM_UTF8(env, str, msg);
 
   isolate->ThrowException(v8::Exception::RangeError(str));
   // any VM calls after this point and before returning
@@ -1583,7 +1617,8 @@ napi_status napi_throw_range_error(napi_env env, const char* msg) {
 napi_status napi_is_error(napi_env env, napi_value value, bool* result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot
   // throw JS exceptions.
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
   *result = val->IsNativeError();
@@ -1596,12 +1631,12 @@ napi_status napi_get_value_double(napi_env env,
                                   double* result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
   // JS exceptions.
-  CHECK_ARG(env);
-  CHECK_ARG(value);
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, value);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
-  RETURN_STATUS_IF_FALSE(val->IsNumber(), napi_number_expected);
+  RETURN_STATUS_IF_FALSE(env, val->IsNumber(), napi_number_expected);
 
   *result = val.As<v8::Number>()->Value();
 
@@ -1613,14 +1648,14 @@ napi_status napi_get_value_int32(napi_env env,
                                  int32_t* result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
   // JS exceptions.
-  CHECK_ARG(env);
-  CHECK_ARG(value);
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, value);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
-  RETURN_STATUS_IF_FALSE(val->IsNumber(), napi_number_expected);
+  RETURN_STATUS_IF_FALSE(env, val->IsNumber(), napi_number_expected);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   *result = val->Int32Value(context).ToChecked();
 
@@ -1632,14 +1667,14 @@ napi_status napi_get_value_uint32(napi_env env,
                                   uint32_t* result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
   // JS exceptions.
-  CHECK_ARG(env);
-  CHECK_ARG(value);
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, value);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
-  RETURN_STATUS_IF_FALSE(val->IsNumber(), napi_number_expected);
+  RETURN_STATUS_IF_FALSE(env, val->IsNumber(), napi_number_expected);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   *result = val->Uint32Value(context).ToChecked();
 
@@ -1651,12 +1686,12 @@ napi_status napi_get_value_int64(napi_env env,
                                  int64_t* result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
   // JS exceptions.
-  CHECK_ARG(env);
-  CHECK_ARG(value);
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, value);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
-  RETURN_STATUS_IF_FALSE(val->IsNumber(), napi_number_expected);
+  RETURN_STATUS_IF_FALSE(env, val->IsNumber(), napi_number_expected);
 
   // v8::Value::IntegerValue() converts NaN to INT64_MIN, inconsistent with
   // v8::Value::Int32Value() that converts NaN to 0. So special-case NaN here.
@@ -1664,7 +1699,7 @@ napi_status napi_get_value_int64(napi_env env,
   if (std::isnan(doubleValue)) {
     *result = 0;
   } else {
-    v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+    v8::Isolate* isolate = env->isolate;
     v8::Local<v8::Context> context = isolate->GetCurrentContext();
     *result = val->IntegerValue(context).ToChecked();
   }
@@ -1675,11 +1710,12 @@ napi_status napi_get_value_int64(napi_env env,
 napi_status napi_get_value_bool(napi_env env, napi_value value, bool* result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
   // JS exceptions.
-  CHECK_ARG(value);
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, value);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
-  RETURN_STATUS_IF_FALSE(val->IsBoolean(), napi_boolean_expected);
+  RETURN_STATUS_IF_FALSE(env, val->IsBoolean(), napi_boolean_expected);
 
   *result = val.As<v8::Boolean>()->Value();
 
@@ -1691,14 +1727,14 @@ napi_status napi_get_value_string_length(napi_env env,
                                          napi_value value,
                                          size_t* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
-  RETURN_STATUS_IF_FALSE(val->IsString(), napi_string_expected);
+  RETURN_STATUS_IF_FALSE(env, val->IsString(), napi_string_expected);
 
   *result = val.As<v8::String>()->Length();
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 // Copies a JavaScript string into a UTF-8 string buffer. The result is the
@@ -1715,10 +1751,10 @@ napi_status napi_get_value_string_utf8(napi_env env,
   NAPI_PREAMBLE(env);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
-  RETURN_STATUS_IF_FALSE(val->IsString(), napi_string_expected);
+  RETURN_STATUS_IF_FALSE(env, val->IsString(), napi_string_expected);
 
   if (!buf) {
-    CHECK_ARG(result);
+    CHECK_ARG(env, result);
     *result = val.As<v8::String>()->Utf8Length();
   } else {
     int copied = val.As<v8::String>()->WriteUtf8(
@@ -1729,7 +1765,7 @@ napi_status napi_get_value_string_utf8(napi_env env,
     }
   }
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 // Copies a JavaScript string into a UTF-16 string buffer. The result is the
@@ -1746,10 +1782,10 @@ napi_status napi_get_value_string_utf16(napi_env env,
   NAPI_PREAMBLE(env);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
-  RETURN_STATUS_IF_FALSE(val->IsString(), napi_string_expected);
+  RETURN_STATUS_IF_FALSE(env, val->IsString(), napi_string_expected);
 
   if (!buf) {
-    CHECK_ARG(result);
+    CHECK_ARG(env, result);
     // V8 assumes UTF-16 length is the same as the number of characters.
     *result = val.As<v8::String>()->Length();
   } else {
@@ -1761,70 +1797,70 @@ napi_status napi_get_value_string_utf16(napi_env env,
     }
   }
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_coerce_to_object(napi_env env,
                                   napi_value value,
                                   napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Object> obj;
-  CHECK_TO_OBJECT(context, obj, value);
+  CHECK_TO_OBJECT(env, context, obj, value);
 
   *result = v8impl::JsValueFromV8LocalValue(obj);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_coerce_to_bool(napi_env env,
                                 napi_value value,
                                 napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Boolean> b;
 
-  CHECK_TO_BOOL(context, b, value);
+  CHECK_TO_BOOL(env, context, b, value);
 
   *result = v8impl::JsValueFromV8LocalValue(b);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_coerce_to_number(napi_env env,
                                   napi_value value,
                                   napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Number> num;
 
-  CHECK_TO_NUMBER(context, num, value);
+  CHECK_TO_NUMBER(env, context, num, value);
 
   *result = v8impl::JsValueFromV8LocalValue(num);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_coerce_to_string(napi_env env,
                                   napi_value value,
                                   napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   v8::Local<v8::String> str;
 
-  CHECK_TO_STRING(context, str, value);
+  CHECK_TO_STRING(env, context, str, value);
 
   *result = v8impl::JsValueFromV8LocalValue(str);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_wrap(napi_env env,
@@ -1834,15 +1870,15 @@ napi_status napi_wrap(napi_env env,
                       void* finalize_hint,
                       napi_ref* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(js_object);
+  CHECK_ARG(env, js_object);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Object> obj =
       v8impl::V8LocalValueFromJsValue(js_object).As<v8::Object>();
 
   // Only objects that were created from a NAPI constructor's prototype
   // via napi_define_class() can be (un)wrapped.
-  RETURN_STATUS_IF_FALSE(obj->InternalFieldCount() > 0, napi_invalid_arg);
+  RETURN_STATUS_IF_FALSE(env, obj->InternalFieldCount() > 0, napi_invalid_arg);
 
   obj->SetInternalField(0, v8::External::New(isolate, native_object));
 
@@ -1851,35 +1887,36 @@ napi_status napi_wrap(napi_env env,
     // ONLY in response to the finalize callback invocation. (If it is deleted
     // before then, then the finalize callback will never be invoked.)
     // Therefore a finalize callback is required when returning a reference.
-    CHECK_ARG(finalize_cb);
+    CHECK_ARG(env, finalize_cb);
     v8impl::Reference* reference = v8impl::Reference::New(
-        isolate, obj, 0, false, finalize_cb, native_object, finalize_hint);
+        env, obj, 0, false, finalize_cb, native_object, finalize_hint);
     *result = reinterpret_cast<napi_ref>(reference);
   } else if (finalize_cb != nullptr) {
     // Create a self-deleting reference just for the finalize callback.
     v8impl::Reference::New(
-        isolate, obj, 0, true, finalize_cb, native_object, finalize_hint);
+        env, obj, 0, true, finalize_cb, native_object, finalize_hint);
   }
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_unwrap(napi_env env, napi_value js_object, void** result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
   // JS exceptions.
-  CHECK_ARG(js_object);
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, js_object);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(js_object);
-  RETURN_STATUS_IF_FALSE(value->IsObject(), napi_invalid_arg);
+  RETURN_STATUS_IF_FALSE(env, value->IsObject(), napi_invalid_arg);
   v8::Local<v8::Object> obj = value.As<v8::Object>();
 
   // Only objects that were created from a NAPI constructor's prototype
   // via napi_define_class() can be (un)wrapped.
-  RETURN_STATUS_IF_FALSE(obj->InternalFieldCount() > 0, napi_invalid_arg);
+  RETURN_STATUS_IF_FALSE(env, obj->InternalFieldCount() > 0, napi_invalid_arg);
 
   v8::Local<v8::Value> unwrappedValue = obj->GetInternalField(0);
-  RETURN_STATUS_IF_FALSE(unwrappedValue->IsExternal(), napi_invalid_arg);
+  RETURN_STATUS_IF_FALSE(env, unwrappedValue->IsExternal(), napi_invalid_arg);
 
   *result = unwrappedValue.As<v8::External>()->Value();
 
@@ -1892,15 +1929,15 @@ napi_status napi_create_external(napi_env env,
                                  void* finalize_hint,
                                  napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
 
   v8::Local<v8::Value> external_value = v8::External::New(isolate, data);
 
   // The Reference object will delete itself after invoking the finalizer
   // callback.
-  v8impl::Reference::New(isolate,
+  v8impl::Reference::New(env,
       external_value,
       0,
       true,
@@ -1910,23 +1947,23 @@ napi_status napi_create_external(napi_env env,
 
   *result = v8impl::JsValueFromV8LocalValue(external_value);
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_get_value_external(napi_env env,
                                     napi_value value,
                                     void** result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(value);
-  CHECK_ARG(result);
+  CHECK_ARG(env, value);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
-  RETURN_STATUS_IF_FALSE(val->IsExternal(), napi_invalid_arg);
+  RETURN_STATUS_IF_FALSE(env, val->IsExternal(), napi_invalid_arg);
 
   v8::Local<v8::External> external_value = val.As<v8::External>();
   *result = external_value->Value();
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 // Set initial_refcount to 0 for a weak reference, >0 for a strong reference.
@@ -1935,15 +1972,13 @@ napi_status napi_create_reference(napi_env env,
                                   uint32_t initial_refcount,
                                   napi_ref* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
-
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  CHECK_ARG(env, result);
 
   v8impl::Reference* reference = v8impl::Reference::New(
-      isolate, v8impl::V8LocalValueFromJsValue(value), initial_refcount, false);
+      env, v8impl::V8LocalValueFromJsValue(value), initial_refcount, false);
 
   *result = reinterpret_cast<napi_ref>(reference);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 // Deletes a reference. The referenced value is released, and may be GC'd unless
@@ -1951,7 +1986,8 @@ napi_status napi_create_reference(napi_env env,
 napi_status napi_delete_reference(napi_env env, napi_ref ref) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
   // JS exceptions.
-  CHECK_ARG(ref);
+  CHECK_ENV(env);
+  CHECK_ARG(env, ref);
 
   v8impl::Reference::Delete(reinterpret_cast<v8impl::Reference*>(ref));
 
@@ -1965,7 +2001,7 @@ napi_status napi_delete_reference(napi_env env, napi_ref ref) {
 // results in an error.
 napi_status napi_reference_ref(napi_env env, napi_ref ref, uint32_t* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(ref);
+  CHECK_ARG(env, ref);
 
   v8impl::Reference* reference = reinterpret_cast<v8impl::Reference*>(ref);
   uint32_t count = reference->Ref();
@@ -1974,7 +2010,7 @@ napi_status napi_reference_ref(napi_env env, napi_ref ref, uint32_t* result) {
     *result = count;
   }
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 // Decrements the reference count, optionally returning the resulting count. If
@@ -1983,12 +2019,12 @@ napi_status napi_reference_ref(napi_env env, napi_ref ref, uint32_t* result) {
 // already 0 results in an error.
 napi_status napi_reference_unref(napi_env env, napi_ref ref, uint32_t* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(ref);
+  CHECK_ARG(env, ref);
 
   v8impl::Reference* reference = reinterpret_cast<v8impl::Reference*>(ref);
 
   if (reference->RefCount() == 0) {
-    return napi_set_last_error(napi_generic_failure);
+    return napi_set_last_error(env, napi_generic_failure);
   }
 
   uint32_t count = reference->Unref();
@@ -1997,7 +2033,7 @@ napi_status napi_reference_unref(napi_env env, napi_ref ref, uint32_t* result) {
     *result = count;
   }
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 // Attempts to get a referenced value. If the reference is weak, the value might
@@ -2007,51 +2043,51 @@ napi_status napi_get_reference_value(napi_env env,
                                      napi_ref ref,
                                      napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(ref);
-  CHECK_ARG(result);
+  CHECK_ARG(env, ref);
+  CHECK_ARG(env, result);
 
   v8impl::Reference* reference = reinterpret_cast<v8impl::Reference*>(ref);
   *result = v8impl::JsValueFromV8LocalValue(reference->Get());
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_open_handle_scope(napi_env env, napi_handle_scope* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   *result = v8impl::JsHandleScopeFromV8HandleScope(
-      new v8impl::HandleScopeWrapper(v8impl::V8IsolateFromJsEnv(env)));
-  return GET_RETURN_STATUS();
+      new v8impl::HandleScopeWrapper(env->isolate));
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_close_handle_scope(napi_env env, napi_handle_scope scope) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(scope);
+  CHECK_ARG(env, scope);
 
   delete v8impl::V8HandleScopeFromJsHandleScope(scope);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_open_escapable_handle_scope(
     napi_env env,
     napi_escapable_handle_scope* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   *result = v8impl::JsEscapableHandleScopeFromV8EscapableHandleScope(
-      new v8impl::EscapableHandleScopeWrapper(v8impl::V8IsolateFromJsEnv(env)));
-  return GET_RETURN_STATUS();
+      new v8impl::EscapableHandleScopeWrapper(env->isolate));
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_close_escapable_handle_scope(
     napi_env env,
     napi_escapable_handle_scope scope) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(scope);
+  CHECK_ARG(env, scope);
 
   delete v8impl::V8EscapableHandleScopeFromJsEscapableHandleScope(scope);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_escape_handle(napi_env env,
@@ -2059,14 +2095,14 @@ napi_status napi_escape_handle(napi_env env,
                                napi_value escapee,
                                napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(scope);
-  CHECK_ARG(result);
+  CHECK_ARG(env, scope);
+  CHECK_ARG(env, result);
 
   v8impl::EscapableHandleScopeWrapper* s =
       v8impl::V8EscapableHandleScopeFromJsEscapableHandleScope(scope);
   *result = v8impl::JsValueFromV8LocalValue(
       s->Escape(v8impl::V8LocalValueFromJsValue(escapee)));
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_new_instance(napi_env env,
@@ -2075,23 +2111,23 @@ napi_status napi_new_instance(napi_env env,
                               const napi_value* argv,
                               napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
 
   v8::Local<v8::Value> v8value = v8impl::V8LocalValueFromJsValue(constructor);
-  RETURN_STATUS_IF_FALSE(v8value->IsFunction(), napi_invalid_arg);
+  RETURN_STATUS_IF_FALSE(env, v8value->IsFunction(), napi_invalid_arg);
 
   v8::Local<v8::Function> ctor = v8value.As<v8::Function>();
 
   auto maybe = ctor->NewInstance(context, argc,
     reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(argv)));
 
-  CHECK_MAYBE_EMPTY(maybe, napi_generic_failure);
+  CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure);
 
   *result = v8impl::JsValueFromV8LocalValue(maybe.ToLocalChecked());
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_instanceof(napi_env env,
@@ -2099,20 +2135,20 @@ napi_status napi_instanceof(napi_env env,
                             napi_value constructor,
                             bool* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   *result = false;
 
   v8::Local<v8::Object> ctor;
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
 
-  CHECK_TO_OBJECT(context, ctor, constructor);
+  CHECK_TO_OBJECT(env, context, ctor, constructor);
 
   if (!ctor->IsFunction()) {
     napi_throw_type_error(env, "constructor must be a function");
 
-    return napi_set_last_error(napi_function_expected);
+    return napi_set_last_error(env, napi_function_expected);
   }
 
   napi_value value, js_result;
@@ -2156,20 +2192,20 @@ napi_status napi_instanceof(napi_env env,
   // a traditional instanceof (early Node.js 6.x).
 
   v8::Local<v8::String> prototype_string;
-  CHECK_NEW_FROM_UTF8(isolate, prototype_string, "prototype");
+  CHECK_NEW_FROM_UTF8(env, prototype_string, "prototype");
 
   auto maybe_prototype = ctor->Get(context, prototype_string);
-  CHECK_MAYBE_EMPTY(maybe_prototype, napi_generic_failure);
+  CHECK_MAYBE_EMPTY(env, maybe_prototype, napi_generic_failure);
 
   v8::Local<v8::Value> prototype_property = maybe_prototype.ToLocalChecked();
   if (!prototype_property->IsObject()) {
     napi_throw_type_error(env, "constructor.prototype must be an object");
 
-    return napi_set_last_error(napi_object_expected);
+    return napi_set_last_error(env, napi_object_expected);
   }
 
   auto maybe_ctor = prototype_property->ToObject(context);
-  CHECK_MAYBE_EMPTY(maybe_ctor, napi_generic_failure);
+  CHECK_MAYBE_EMPTY(env, maybe_ctor, napi_generic_failure);
   ctor = maybe_ctor.ToLocalChecked();
 
   v8::Local<v8::Value> current_obj = v8impl::V8LocalValueFromJsValue(object);
@@ -2183,13 +2219,13 @@ napi_status napi_instanceof(napi_env env,
         break;
       }
       v8::Local<v8::Object> obj;
-      CHECK_TO_OBJECT(context, obj, v8impl::JsValueFromV8LocalValue(
+      CHECK_TO_OBJECT(env, context, obj, v8impl::JsValueFromV8LocalValue(
         current_obj));
       current_obj = obj->GetPrototype();
     }
   }
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_make_callback(napi_env env,
@@ -2200,7 +2236,7 @@ napi_status napi_make_callback(napi_env env,
                                napi_value* result) {
   NAPI_PREAMBLE(env);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Object> v8recv =
       v8impl::V8LocalValueFromJsValue(recv).As<v8::Object>();
   v8::Local<v8::Function> v8func =
@@ -2214,17 +2250,17 @@ napi_status napi_make_callback(napi_env env,
     *result = v8impl::JsValueFromV8LocalValue(callback_result);
   }
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 // Methods to support catching exceptions
 napi_status napi_is_exception_pending(napi_env env, bool* result) {
   // NAPI_PREAMBLE is not used here: this function must execute when there is a
   // pending exception.
-  CHECK_ARG(env);
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
 
-  *result = !v8impl::TryCatch::LastException().IsEmpty();
+  *result = !env->last_exception.IsEmpty();
   return napi_ok;
 }
 
@@ -2232,15 +2268,15 @@ napi_status napi_get_and_clear_last_exception(napi_env env,
                                               napi_value* result) {
   // NAPI_PREAMBLE is not used here: this function must execute when there is a
   // pending exception.
-  CHECK_ARG(env);
-  CHECK_ARG(result);
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
 
-  if (v8impl::TryCatch::LastException().IsEmpty()) {
+  if (env->last_exception.IsEmpty()) {
     return napi_get_undefined(env, result);
   } else {
-    *result = v8impl::JsValueFromV8LocalValue(v8::Local<v8::Value>::New(
-        v8impl::V8IsolateFromJsEnv(env), v8impl::TryCatch::LastException()));
-    v8impl::TryCatch::LastException().Reset();
+    *result = v8impl::JsValueFromV8LocalValue(
+      v8::Local<v8::Value>::New(env->isolate, env->last_exception));
+    env->last_exception.Reset();
   }
 
   return napi_ok;
@@ -2251,19 +2287,19 @@ napi_status napi_create_buffer(napi_env env,
                                void** data,
                                napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(data);
-  CHECK_ARG(result);
+  CHECK_ARG(env, data);
+  CHECK_ARG(env, result);
 
-  auto maybe = node::Buffer::New(v8impl::V8IsolateFromJsEnv(env), length);
+  auto maybe = node::Buffer::New(env->isolate, length);
 
-  CHECK_MAYBE_EMPTY(maybe, napi_generic_failure);
+  CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure);
 
   v8::Local<v8::Object> buffer = maybe.ToLocalChecked();
 
   *result = v8impl::JsValueFromV8LocalValue(buffer);
   *data = node::Buffer::Data(buffer);
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_create_external_buffer(napi_env env,
@@ -2273,13 +2309,13 @@ napi_status napi_create_external_buffer(napi_env env,
                                         void* finalize_hint,
                                         napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
 
   // The finalizer object will delete itself after invoking the callback.
   v8impl::Finalizer* finalizer = v8impl::Finalizer::New(
-    isolate, finalize_cb, nullptr, finalize_hint);
+    env, finalize_cb, nullptr, finalize_hint);
 
   auto maybe = node::Buffer::New(isolate,
                                  static_cast<char*>(data),
@@ -2287,10 +2323,10 @@ napi_status napi_create_external_buffer(napi_env env,
                                  v8impl::Finalizer::FinalizeBufferCallback,
                                  finalizer);
 
-  CHECK_MAYBE_EMPTY(maybe, napi_generic_failure);
+  CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure);
 
   *result = v8impl::JsValueFromV8LocalValue(maybe.ToLocalChecked());
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
   // Tell coverity that 'finalizer' should not be freed when we return
   // as it will be deleted when the buffer to which it is associated
   // is finalized.
@@ -2303,12 +2339,12 @@ napi_status napi_create_buffer_copy(napi_env env,
                                     void** result_data,
                                     napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  auto maybe = node::Buffer::Copy(v8impl::V8IsolateFromJsEnv(env),
+  auto maybe = node::Buffer::Copy(env->isolate,
     static_cast<const char*>(data), length);
 
-  CHECK_MAYBE_EMPTY(maybe, napi_generic_failure);
+  CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure);
 
   v8::Local<v8::Object> buffer = maybe.ToLocalChecked();
   *result = v8impl::JsValueFromV8LocalValue(buffer);
@@ -2317,15 +2353,15 @@ napi_status napi_create_buffer_copy(napi_env env,
     *result_data = node::Buffer::Data(buffer);
   }
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_is_buffer(napi_env env, napi_value value, bool* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   *result = node::Buffer::HasInstance(v8impl::V8LocalValueFromJsValue(value));
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_get_buffer_info(napi_env env,
@@ -2344,17 +2380,17 @@ napi_status napi_get_buffer_info(napi_env env,
     *length = node::Buffer::Length(buffer);
   }
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_is_arraybuffer(napi_env env, napi_value value, bool* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
   *result = val->IsArrayBuffer();
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_create_arraybuffer(napi_env env,
@@ -2362,9 +2398,9 @@ napi_status napi_create_arraybuffer(napi_env env,
                                     void** data,
                                     napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::ArrayBuffer> buffer =
       v8::ArrayBuffer::New(isolate, byte_length);
 
@@ -2375,7 +2411,7 @@ napi_status napi_create_arraybuffer(napi_env env,
   }
 
   *result = v8impl::JsValueFromV8LocalValue(buffer);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_create_external_arraybuffer(napi_env env,
@@ -2385,16 +2421,16 @@ napi_status napi_create_external_arraybuffer(napi_env env,
                                              void* finalize_hint,
                                              napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
-  v8::Isolate* isolate = v8impl::V8IsolateFromJsEnv(env);
+  v8::Isolate* isolate = env->isolate;
   v8::Local<v8::ArrayBuffer> buffer =
       v8::ArrayBuffer::New(isolate, external_data, byte_length);
 
   if (finalize_cb != nullptr) {
     // Create a self-deleting weak reference that invokes the finalizer
     // callback.
-    v8impl::Reference::New(isolate,
+    v8impl::Reference::New(env,
         buffer,
         0,
         true,
@@ -2404,7 +2440,7 @@ napi_status napi_create_external_arraybuffer(napi_env env,
   }
 
   *result = v8impl::JsValueFromV8LocalValue(buffer);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_get_arraybuffer_info(napi_env env,
@@ -2414,7 +2450,7 @@ napi_status napi_get_arraybuffer_info(napi_env env,
   NAPI_PREAMBLE(env);
 
   v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(arraybuffer);
-  RETURN_STATUS_IF_FALSE(value->IsArrayBuffer(), napi_invalid_arg);
+  RETURN_STATUS_IF_FALSE(env, value->IsArrayBuffer(), napi_invalid_arg);
 
   v8::ArrayBuffer::Contents contents =
       value.As<v8::ArrayBuffer>()->GetContents();
@@ -2427,17 +2463,17 @@ napi_status napi_get_arraybuffer_info(napi_env env,
     *byte_length = contents.ByteLength();
   }
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_is_typedarray(napi_env env, napi_value value, bool* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
   *result = val->IsTypedArray();
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_create_typedarray(napi_env env,
@@ -2447,10 +2483,10 @@ napi_status napi_create_typedarray(napi_env env,
                                    size_t byte_offset,
                                    napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(result);
+  CHECK_ARG(env, result);
 
   v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(arraybuffer);
-  RETURN_STATUS_IF_FALSE(value->IsArrayBuffer(), napi_invalid_arg);
+  RETURN_STATUS_IF_FALSE(env, value->IsArrayBuffer(), napi_invalid_arg);
 
   v8::Local<v8::ArrayBuffer> buffer = value.As<v8::ArrayBuffer>();
   v8::Local<v8::TypedArray> typedArray;
@@ -2484,11 +2520,11 @@ napi_status napi_create_typedarray(napi_env env,
       typedArray = v8::Float64Array::New(buffer, byte_offset, length);
       break;
     default:
-      return napi_set_last_error(napi_invalid_arg);
+      return napi_set_last_error(env, napi_invalid_arg);
   }
 
   *result = v8impl::JsValueFromV8LocalValue(typedArray);
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_get_typedarray_info(napi_env env,
@@ -2501,7 +2537,7 @@ napi_status napi_get_typedarray_info(napi_env env,
   NAPI_PREAMBLE(env);
 
   v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(typedarray);
-  RETURN_STATUS_IF_FALSE(value->IsTypedArray(), napi_invalid_arg);
+  RETURN_STATUS_IF_FALSE(env, value->IsTypedArray(), napi_invalid_arg);
 
   v8::Local<v8::TypedArray> array = value.As<v8::TypedArray>();
 
@@ -2545,5 +2581,5 @@ napi_status napi_get_typedarray_info(napi_env env,
     *byte_offset = array->ByteOffset();
   }
 
-  return GET_RETURN_STATUS();
+  return GET_RETURN_STATUS(env);
 }
diff --git a/test/addons-napi/test_napi_status/binding.gyp b/test/addons-napi/test_napi_status/binding.gyp
new file mode 100644
index 00000000000000..01ace540a99781
--- /dev/null
+++ b/test/addons-napi/test_napi_status/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_napi_status",
+      "sources": [ "test_napi_status.cc" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_napi_status/test.js b/test/addons-napi/test_napi_status/test.js
new file mode 100644
index 00000000000000..60c4f693b2d951
--- /dev/null
+++ b/test/addons-napi/test_napi_status/test.js
@@ -0,0 +1,8 @@
+'use strict';
+
+const common = require('../../common');
+const addon = require(`./build/${common.buildType}/test_napi_status`);
+const assert = require('assert');
+
+addon.createNapiError();
+assert(addon.testNapiErrorCleanup(), 'napi_status cleaned up for second call');
diff --git a/test/addons-napi/test_napi_status/test_napi_status.cc b/test/addons-napi/test_napi_status/test_napi_status.cc
new file mode 100644
index 00000000000000..b22e1db7638755
--- /dev/null
+++ b/test/addons-napi/test_napi_status/test_napi_status.cc
@@ -0,0 +1,47 @@
+#include <node_api.h>
+
+#define DECLARE_NAPI_METHOD(func) \
+  { #func, func, 0, 0, 0, napi_default, 0 }
+
+void createNapiError(napi_env env, napi_callback_info info) {
+  napi_status status;
+  napi_value value;
+  double double_value;
+
+  status = napi_create_string_utf8(env, "xyz", 3, &value);
+  if (status != napi_ok) return;
+
+  status = napi_get_value_double(env, value, &double_value);
+  if (status == napi_ok) {
+    napi_throw_error(env, "Failed to produce error condition");
+  }
+}
+
+void testNapiErrorCleanup(napi_env env, napi_callback_info info) {
+  napi_status status;
+  const napi_extended_error_info *error_info = 0;
+  napi_value result;
+
+  status = napi_get_last_error_info(env, &error_info);
+  if (status != napi_ok) return;
+
+  status = napi_get_boolean(env, (error_info->error_code == napi_ok), &result);
+  if (status != napi_ok) return;
+
+  napi_set_return_value(env, info, result);
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+
+  napi_property_descriptor descriptors[] = {
+      DECLARE_NAPI_METHOD(createNapiError),
+      DECLARE_NAPI_METHOD(testNapiErrorCleanup)
+  };
+
+  status = napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)

From 8047b418534abd39c9c960f073d1fa83a95e4c37 Mon Sep 17 00:00:00 2001
From: Jason Ginchereau <jasongin@microsoft.com>
Date: Wed, 5 Apr 2017 10:18:56 -0700
Subject: [PATCH 005/183] n-api: Update property attrs enum to match JS spec

The napi_property_attributes enum used names and values from
v8::PropertyAttribute, but those negative flag names were outdated
along with the default behavior of a property being writable,
enumerable, and configurable unless otherwise specified. To match the
ES5 standard property descriptor those attributes should be positive
flags and should default to false unless otherwise specified.

PR-URL: https://github.com/nodejs/node/pull/12240
Fixes: https://github.com/nodejs/abi-stable-node/issues/221
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
---
 src/node_api.cc                               | 107 ++++++++++--------
 src/node_api_types.h                          |   8 +-
 test/addons-napi/test_constructor/test.js     |  16 ++-
 .../test_constructor/test_constructor.c       |  13 ++-
 test/addons-napi/test_properties/test.js      |  16 ++-
 .../test_properties/test_properties.c         |  13 ++-
 6 files changed, 107 insertions(+), 66 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 5534f78893364c..cde22cbf4f318a 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -37,18 +37,26 @@ class napi_env__ {
 namespace v8impl {
 
 // convert from n-api property attributes to v8::PropertyAttribute
-static inline v8::PropertyAttribute V8PropertyAttributesFromAttributes(
-    napi_property_attributes attributes) {
-  unsigned int attribute_flags = v8::None;
-  if (attributes & napi_read_only) {
-    attribute_flags |= v8::ReadOnly;
+static inline v8::PropertyAttribute V8PropertyAttributesFromDescriptor(
+    const napi_property_descriptor* descriptor) {
+  unsigned int attribute_flags = v8::PropertyAttribute::None;
+
+  if (descriptor->getter != nullptr || descriptor->setter != nullptr) {
+    // The napi_writable attribute is ignored for accessor descriptors, but
+    // V8 requires the ReadOnly attribute to match nonexistence of a setter.
+    attribute_flags |= (descriptor->setter == nullptr ?
+      v8::PropertyAttribute::ReadOnly : v8::PropertyAttribute::None);
+  } else if ((descriptor->attributes & napi_writable) == 0) {
+    attribute_flags |= v8::PropertyAttribute::ReadOnly;
   }
-  if (attributes & napi_dont_enum) {
-    attribute_flags |= v8::DontEnum;
+
+  if ((descriptor->attributes & napi_enumerable) == 0) {
+    attribute_flags |= v8::PropertyAttribute::DontEnum;
   }
-  if (attributes & napi_dont_delete) {
-    attribute_flags |= v8::DontDelete;
+  if ((descriptor->attributes & napi_configurable) == 0) {
+    attribute_flags |= v8::PropertyAttribute::DontDelete;
   }
+
   return static_cast<v8::PropertyAttribute>(attribute_flags);
 }
 
@@ -777,7 +785,7 @@ napi_status napi_define_class(napi_env env,
   for (size_t i = 0; i < property_count; i++) {
     const napi_property_descriptor* p = properties + i;
 
-    if ((p->attributes & napi_static_property) != 0) {
+    if ((p->attributes & napi_static) != 0) {
       // Static properties are handled separately below.
       static_property_count++;
       continue;
@@ -786,25 +794,11 @@ napi_status napi_define_class(napi_env env,
     v8::Local<v8::String> property_name;
     CHECK_NEW_FROM_UTF8(env, property_name, p->utf8name);
     v8::PropertyAttribute attributes =
-        v8impl::V8PropertyAttributesFromAttributes(p->attributes);
+        v8impl::V8PropertyAttributesFromDescriptor(p);
 
-    // This code is similar to that in napi_define_property(); the
+    // This code is similar to that in napi_define_properties(); the
     // difference is it applies to a template instead of an object.
-    if (p->method) {
-      v8::Local<v8::Object> cbdata =
-          v8impl::CreateFunctionCallbackData(env, p->method, p->data);
-
-      RETURN_STATUS_IF_FALSE(env, !cbdata.IsEmpty(), napi_generic_failure);
-
-      v8::Local<v8::FunctionTemplate> t =
-          v8::FunctionTemplate::New(isolate,
-                                    v8impl::FunctionCallbackWrapper::Invoke,
-                                    cbdata,
-                                    v8::Signature::New(isolate, tpl));
-      t->SetClassName(property_name);
-
-      tpl->PrototypeTemplate()->Set(property_name, t, attributes);
-    } else if (p->getter || p->setter) {
+    if (p->getter != nullptr || p->setter != nullptr) {
       v8::Local<v8::Object> cbdata = v8impl::CreateAccessorCallbackData(
         env, p->getter, p->setter, p->data);
 
@@ -815,6 +809,20 @@ napi_status napi_define_class(napi_env env,
         cbdata,
         v8::AccessControl::DEFAULT,
         attributes);
+    } else if (p->method != nullptr) {
+      v8::Local<v8::Object> cbdata =
+          v8impl::CreateFunctionCallbackData(env, p->method, p->data);
+
+      RETURN_STATUS_IF_FALSE(env, !cbdata.IsEmpty(), napi_generic_failure);
+
+      v8::Local<v8::FunctionTemplate> t =
+        v8::FunctionTemplate::New(isolate,
+          v8impl::FunctionCallbackWrapper::Invoke,
+          cbdata,
+          v8::Signature::New(isolate, tpl));
+      t->SetClassName(property_name);
+
+      tpl->PrototypeTemplate()->Set(property_name, t, attributes);
     } else {
       v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(p->value);
       tpl->PrototypeTemplate()->Set(property_name, value, attributes);
@@ -829,7 +837,7 @@ napi_status napi_define_class(napi_env env,
 
     for (size_t i = 0; i < property_count; i++) {
       const napi_property_descriptor* p = properties + i;
-      if ((p->attributes & napi_static_property) != 0) {
+      if ((p->attributes & napi_static) != 0) {
         static_descriptors.push_back(*p);
       }
     }
@@ -1096,10 +1104,28 @@ napi_status napi_define_properties(napi_env env,
     CHECK_NEW_FROM_UTF8(env, name, p->utf8name);
 
     v8::PropertyAttribute attributes =
-        v8impl::V8PropertyAttributesFromAttributes(
-            (napi_property_attributes)(p->attributes & ~napi_static_property));
+          v8impl::V8PropertyAttributesFromDescriptor(p);
+
+    if (p->getter != nullptr || p->setter != nullptr) {
+      v8::Local<v8::Object> cbdata = v8impl::CreateAccessorCallbackData(
+        env,
+        p->getter,
+        p->setter,
+        p->data);
 
-    if (p->method) {
+      auto set_maybe = obj->SetAccessor(
+        context,
+        name,
+        p->getter ? v8impl::GetterCallbackWrapper::Invoke : nullptr,
+        p->setter ? v8impl::SetterCallbackWrapper::Invoke : nullptr,
+        cbdata,
+        v8::AccessControl::DEFAULT,
+        attributes);
+
+      if (!set_maybe.FromMaybe(false)) {
+        return napi_set_last_error(env, napi_invalid_arg);
+      }
+    } else if (p->method != nullptr) {
       v8::Local<v8::Object> cbdata =
           v8impl::CreateFunctionCallbackData(env, p->method, p->data);
 
@@ -1114,25 +1140,6 @@ napi_status napi_define_properties(napi_env env,
       if (!define_maybe.FromMaybe(false)) {
         return napi_set_last_error(env, napi_generic_failure);
       }
-    } else if (p->getter || p->setter) {
-      v8::Local<v8::Object> cbdata = v8impl::CreateAccessorCallbackData(
-        env,
-        p->getter,
-        p->setter,
-        p->data);
-
-      auto set_maybe = obj->SetAccessor(
-          context,
-          name,
-          p->getter ? v8impl::GetterCallbackWrapper::Invoke : nullptr,
-          p->setter ? v8impl::SetterCallbackWrapper::Invoke : nullptr,
-          cbdata,
-          v8::AccessControl::DEFAULT,
-          attributes);
-
-      if (!set_maybe.FromMaybe(false)) {
-        return napi_set_last_error(env, napi_invalid_arg);
-      }
     } else {
       v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(p->value);
 
diff --git a/src/node_api_types.h b/src/node_api_types.h
index 7cb242368a367e..f3f3faaa641cbb 100644
--- a/src/node_api_types.h
+++ b/src/node_api_types.h
@@ -25,13 +25,13 @@ typedef void (*napi_finalize)(napi_env env,
 
 typedef enum {
   napi_default = 0,
-  napi_read_only = 1 << 0,
-  napi_dont_enum = 1 << 1,
-  napi_dont_delete = 1 << 2,
+  napi_writable = 1 << 0,
+  napi_enumerable = 1 << 1,
+  napi_configurable = 1 << 2,
 
   // Used with napi_define_class to distinguish static properties
   // from instance properties. Ignored by napi_define_properties.
-  napi_static_property = 1 << 10,
+  napi_static = 1 << 10,
 } napi_property_attributes;
 
 typedef struct {
diff --git a/test/addons-napi/test_constructor/test.js b/test/addons-napi/test_constructor/test.js
index 9feae5a1360b2c..b1762c2253b99a 100644
--- a/test/addons-napi/test_constructor/test.js
+++ b/test/addons-napi/test_constructor/test.js
@@ -17,7 +17,7 @@ assert.throws(() => { test_object.readonlyValue = 3; });
 
 assert.ok(test_object.hiddenValue);
 
-// All properties except 'hiddenValue' should be enumerable.
+// Properties with napi_enumerable attribute should be enumerable.
 const propertyNames = [];
 for (const name in test_object) {
   propertyNames.push(name);
@@ -26,3 +26,17 @@ assert.ok(propertyNames.indexOf('echo') >= 0);
 assert.ok(propertyNames.indexOf('readwriteValue') >= 0);
 assert.ok(propertyNames.indexOf('readonlyValue') >= 0);
 assert.ok(propertyNames.indexOf('hiddenValue') < 0);
+assert.ok(propertyNames.indexOf('readwriteAccessor1') < 0);
+assert.ok(propertyNames.indexOf('readwriteAccessor2') < 0);
+assert.ok(propertyNames.indexOf('readonlyAccessor1') < 0);
+assert.ok(propertyNames.indexOf('readonlyAccessor2') < 0);
+
+// The napi_writable attribute should be ignored for accessors.
+test_object.readwriteAccessor1 = 1;
+assert.strictEqual(test_object.readwriteAccessor1, 1);
+assert.strictEqual(test_object.readonlyAccessor1, 1);
+assert.throws(() => { test_object.readonlyAccessor1 = 3; });
+test_object.readwriteAccessor2 = 2;
+assert.strictEqual(test_object.readwriteAccessor2, 2);
+assert.strictEqual(test_object.readonlyAccessor2, 2);
+assert.throws(() => { test_object.readonlyAccessor2 = 3; });
diff --git a/test/addons-napi/test_constructor/test_constructor.c b/test/addons-napi/test_constructor/test_constructor.c
index 5a45da30739d6d..d0382f2c65ba5e 100644
--- a/test/addons-napi/test_constructor/test_constructor.c
+++ b/test/addons-napi/test_constructor/test_constructor.c
@@ -82,11 +82,14 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   if (status != napi_ok) return;
 
   napi_property_descriptor properties[] = {
-      { "echo", Echo, 0, 0, 0, napi_default, 0 },
-      { "accessorValue", 0, GetValue, SetValue, 0, napi_default, 0},
-      { "readwriteValue", 0, 0, 0, number, napi_default, 0 },
-      { "readonlyValue", 0, 0, 0, number, napi_read_only, 0},
-      { "hiddenValue", 0, 0, 0, number, napi_read_only | napi_dont_enum, 0},
+      { "echo", Echo, 0, 0, 0, napi_enumerable, 0 },
+      { "readwriteValue", 0, 0, 0, number, napi_enumerable | napi_writable, 0 },
+      { "readonlyValue", 0, 0, 0, number, napi_enumerable, 0},
+      { "hiddenValue", 0, 0, 0, number, napi_default, 0},
+      { "readwriteAccessor1", 0, GetValue, SetValue, 0, napi_default, 0},
+      { "readwriteAccessor2", 0, GetValue, SetValue, 0, napi_writable, 0},
+      { "readonlyAccessor1", 0, GetValue, NULL, 0, napi_default, 0},
+      { "readonlyAccessor2", 0, GetValue, NULL, 0, napi_writable, 0},
   };
 
   napi_value cons;
diff --git a/test/addons-napi/test_properties/test.js b/test/addons-napi/test_properties/test.js
index 8e19903dcfe6e6..fb0c19ceedb086 100644
--- a/test/addons-napi/test_properties/test.js
+++ b/test/addons-napi/test_properties/test.js
@@ -16,7 +16,7 @@ assert.throws(() => { test_object.readonlyValue = 3; });
 
 assert.ok(test_object.hiddenValue);
 
-// All properties except 'hiddenValue' should be enumerable.
+// Properties with napi_enumerable attribute should be enumerable.
 const propertyNames = [];
 for (const name in test_object) {
   propertyNames.push(name);
@@ -25,3 +25,17 @@ assert.ok(propertyNames.indexOf('echo') >= 0);
 assert.ok(propertyNames.indexOf('readwriteValue') >= 0);
 assert.ok(propertyNames.indexOf('readonlyValue') >= 0);
 assert.ok(propertyNames.indexOf('hiddenValue') < 0);
+assert.ok(propertyNames.indexOf('readwriteAccessor1') < 0);
+assert.ok(propertyNames.indexOf('readwriteAccessor2') < 0);
+assert.ok(propertyNames.indexOf('readonlyAccessor1') < 0);
+assert.ok(propertyNames.indexOf('readonlyAccessor2') < 0);
+
+// The napi_writable attribute should be ignored for accessors.
+test_object.readwriteAccessor1 = 1;
+assert.strictEqual(test_object.readwriteAccessor1, 1);
+assert.strictEqual(test_object.readonlyAccessor1, 1);
+assert.throws(() => { test_object.readonlyAccessor1 = 3; });
+test_object.readwriteAccessor2 = 2;
+assert.strictEqual(test_object.readwriteAccessor2, 2);
+assert.strictEqual(test_object.readonlyAccessor2, 2);
+assert.throws(() => { test_object.readonlyAccessor2 = 3; });
diff --git a/test/addons-napi/test_properties/test_properties.c b/test/addons-napi/test_properties/test_properties.c
index 9474e97266649b..de6b39ba027577 100644
--- a/test/addons-napi/test_properties/test_properties.c
+++ b/test/addons-napi/test_properties/test_properties.c
@@ -70,11 +70,14 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   if (status != napi_ok) return;
 
   napi_property_descriptor properties[] = {
-      { "echo", Echo, 0, 0, 0, napi_default, 0 },
-      { "accessorValue", 0, GetValue, SetValue, 0, napi_default, 0 },
-      { "readwriteValue", 0, 0, 0, number, napi_default, 0 },
-      { "readonlyValue", 0, 0, 0, number, napi_read_only, 0 },
-      { "hiddenValue", 0, 0, 0, number, napi_read_only | napi_dont_enum, 0 },
+      { "echo", Echo, 0, 0, 0, napi_enumerable, 0 },
+      { "readwriteValue", 0, 0, 0, number, napi_enumerable | napi_writable, 0 },
+      { "readonlyValue", 0, 0, 0, number, napi_enumerable, 0},
+      { "hiddenValue", 0, 0, 0, number, napi_default, 0},
+      { "readwriteAccessor1", 0, GetValue, SetValue, 0, napi_default, 0},
+      { "readwriteAccessor2", 0, GetValue, SetValue, 0, napi_writable, 0},
+      { "readonlyAccessor1", 0, GetValue, NULL, 0, napi_default, 0},
+      { "readonlyAccessor2", 0, GetValue, NULL, 0, napi_writable, 0},
   };
 
   status = napi_define_properties(

From 7afb3bc615ad7d5d42ba40ba5d6caabf5a1d6161 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Fri, 31 Mar 2017 16:40:33 +0300
Subject: [PATCH 006/183] n-api: cache Symbol.hasInstance

This improves the performance of napi_instanceof() by retrieving
Symbol.hasInstance from the global object once and then storing a
persistent reference to it in the env.

PR-URL: https://github.com/nodejs/node/pull/12246
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 src/node_api.cc | 61 +++++++++++++++++++++++++++++++++----------------
 1 file changed, 41 insertions(+), 20 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index cde22cbf4f318a..c6d825230fbcb6 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -25,12 +25,16 @@ void napi_clear_last_error(napi_env env);
 
 class napi_env__ {
  public:
-  explicit napi_env__(v8::Isolate* _isolate): isolate(_isolate), last_error() {}
+  explicit napi_env__(v8::Isolate* _isolate): isolate(_isolate),
+      has_instance_available(true), last_error() {}
   ~napi_env__() {
     last_exception.Reset();
+    has_instance.Reset();
   }
   v8::Isolate* isolate;
   v8::Persistent<v8::Value> last_exception;
+  v8::Persistent<v8::Value> has_instance;
+  bool has_instance_available;
   napi_extended_error_info last_error;
 };
 
@@ -2158,28 +2162,43 @@ napi_status napi_instanceof(napi_env env,
     return napi_set_last_error(env, napi_function_expected);
   }
 
-  napi_value value, js_result;
-  napi_status status;
-  napi_valuetype value_type;
+  if (env->has_instance_available) {
+    napi_value value, js_result, has_instance = nullptr;
+    napi_status status;
+    napi_valuetype value_type;
 
-  // Get "Symbol" from the global object
-  status = napi_get_global(env, &value);
-  if (status != napi_ok) return status;
-  status = napi_get_named_property(env, value, "Symbol", &value);
-  if (status != napi_ok) return status;
-  status = napi_typeof(env, value, &value_type);
-  if (status != napi_ok) return status;
+    // Get "Symbol" from the global object
+    if (env->has_instance.IsEmpty()) {
+      status = napi_get_global(env, &value);
+      if (status != napi_ok) return status;
+      status = napi_get_named_property(env, value, "Symbol", &value);
+      if (status != napi_ok) return status;
+      status = napi_typeof(env, value, &value_type);
+      if (status != napi_ok) return status;
 
-  // Get "hasInstance" from Symbol
-  if (value_type == napi_function) {
-    status = napi_get_named_property(env, value, "hasInstance", &value);
-    if (status != napi_ok) return status;
-    status = napi_typeof(env, value, &value_type);
-    if (status != napi_ok) return status;
+      // Get "hasInstance" from Symbol
+      if (value_type == napi_function) {
+        status = napi_get_named_property(env, value, "hasInstance", &value);
+        if (status != napi_ok) return status;
+        status = napi_typeof(env, value, &value_type);
+        if (status != napi_ok) return status;
+
+        // Store Symbol.hasInstance in a global persistent reference
+        if (value_type == napi_symbol) {
+          env->has_instance.Reset(env->isolate,
+              v8impl::V8LocalValueFromJsValue(value));
+          if (status != napi_ok) return status;
+          has_instance = value;
+        }
+      }
+    } else {
+      has_instance = v8impl::JsValueFromV8LocalValue(
+          v8::Local<v8::Value>::New(env->isolate, env->has_instance));
+      if (status != napi_ok) return status;
+    }
 
-    // Retrieve the function at the Symbol(hasInstance) key of the constructor
-    if (value_type == napi_symbol) {
-      status = napi_get_property(env, constructor, value, &value);
+    if (has_instance) {
+      status = napi_get_property(env, constructor, has_instance, &value);
       if (status != napi_ok) return status;
       status = napi_typeof(env, value, &value_type);
       if (status != napi_ok) return status;
@@ -2193,6 +2212,8 @@ napi_status napi_instanceof(napi_env env,
         return napi_get_value_bool(env, js_result, result);
       }
     }
+
+    env->has_instance_available = false;
   }
 
   // If running constructor[Symbol.hasInstance](object) did not work, we perform

From 1459aeaf0119d7c5d05e7d5987420b7d7490e9b7 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Sat, 8 Apr 2017 16:12:13 +0300
Subject: [PATCH 007/183] napi: initialize and check status properly

Initialize status to napi_generic_failure and only check it after
having made an actual N-API call.

This fixes up 8fbace163afbd61b5efc57cf94414be904bf0188.

PR-URL: https://github.com/nodejs/node/pull/12283
Ref: https://github.com/nodejs/node/pull/12279
Reviewed-By: Refael Ackermann <refack@gmail.com>
---
 src/node_api.cc | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index c6d825230fbcb6..b61157a8f317ff 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -2164,7 +2164,7 @@ napi_status napi_instanceof(napi_env env,
 
   if (env->has_instance_available) {
     napi_value value, js_result, has_instance = nullptr;
-    napi_status status;
+    napi_status status = napi_generic_failure;
     napi_valuetype value_type;
 
     // Get "Symbol" from the global object
@@ -2187,14 +2187,12 @@ napi_status napi_instanceof(napi_env env,
         if (value_type == napi_symbol) {
           env->has_instance.Reset(env->isolate,
               v8impl::V8LocalValueFromJsValue(value));
-          if (status != napi_ok) return status;
           has_instance = value;
         }
       }
     } else {
       has_instance = v8impl::JsValueFromV8LocalValue(
           v8::Local<v8::Value>::New(env->isolate, env->has_instance));
-      if (status != napi_ok) return status;
     }
 
     if (has_instance) {

From 630b4bf11ebfc2595c27fe461868cb6ac5fc77a8 Mon Sep 17 00:00:00 2001
From: Taylor Woll <taylor.woll@microsoft.com>
Date: Fri, 24 Mar 2017 01:26:09 -0700
Subject: [PATCH 008/183] n-api: change napi_callback to return napi_value

Change `napi_callback` to return `napi_value` directly instead of
requiring `napi_set_return_value`.

When we invoke the callback, we will check the return value and
call `SetReturnValue` ourselves. If the callback returns `NULL`,
we don't set the return value in v8 which would have the same
effect as previously if the callback didn't call
`napi_set_return_value`. Seems to be a more natural way
to handle return values from callbacks. As a consequence,
remove `napi_set_return_value`.

Add a `napi_value` to `napi_property_descriptor` to support string
values which couldn't be passed in the `utf8name` parameter or
symbols as property names. Class names, however, cannot be symbols
so this `napi_value` must be a string type in that case.

Remove all of the `napi_callback_info` helpers except for
`napi_get_cb_info` and make all the parameters to
`napi_get_cb_info` optional except for argc.

Update all the test collateral according to these changes.
Also add `test/addons-napi/common.h` to house some common macros
for wrapping N-API calls and error handling.

PR-URL: https://github.com/nodejs/node/pull/12248
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 src/node_api.cc                               | 275 ++++++++----------
 src/node_api.h                                |  21 +-
 src/node_api_types.h                          |   7 +-
 test/addons-napi/1_hello_world/binding.c      |  22 +-
 .../2_function_arguments/binding.c            |  53 +---
 test/addons-napi/3_callbacks/binding.c        |  44 ++-
 test/addons-napi/4_object_factory/binding.c   |  28 +-
 test/addons-napi/5_function_factory/binding.c |  31 +-
 test/addons-napi/6_object_wrap/myobject.cc    | 196 +++++--------
 test/addons-napi/6_object_wrap/myobject.h     |  10 +-
 test/addons-napi/7_factory_wrap/binding.cc    |  29 +-
 test/addons-napi/7_factory_wrap/myobject.cc   |  62 ++--
 test/addons-napi/7_factory_wrap/myobject.h    |   4 +-
 test/addons-napi/8_passing_wrapped/binding.cc |  49 ++--
 .../addons-napi/8_passing_wrapped/myobject.cc |  38 +--
 test/addons-napi/8_passing_wrapped/myobject.h |   2 +-
 test/addons-napi/common.h                     |  52 ++++
 test/addons-napi/test_array/test_array.c      | 148 ++++------
 test/addons-napi/test_buffer/test_buffer.c    | 114 ++++----
 .../test_constructor/test_constructor.c       | 111 +++----
 .../test_conversions/test_conversions.c       | 246 +++++-----------
 test/addons-napi/test_error/test_error.cc     |  32 +-
 .../test_exception/test_exception.c           |  72 ++---
 .../addons-napi/test_function/test_function.c |  50 +---
 .../test_instanceof/test_instanceof.c         |  33 +--
 .../test_napi_status/test_napi_status.cc      |  44 ++-
 test/addons-napi/test_number/test_number.c    |  52 +---
 test/addons-napi/test_object/test_object.c    | 246 +++++-----------
 .../test_properties/test_properties.c         |  91 ++----
 test/addons-napi/test_string/test_string.c    | 133 +++------
 test/addons-napi/test_symbol/test_symbol.c    | 100 +++----
 .../test_typedarray/test_typedarray.c         | 134 ++++-----
 32 files changed, 939 insertions(+), 1590 deletions(-)
 create mode 100644 test/addons-napi/common.h

diff --git a/src/node_api.cc b/src/node_api.cc
index b61157a8f317ff..35f737619ef239 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -38,6 +38,70 @@ class napi_env__ {
   napi_extended_error_info last_error;
 };
 
+#define RETURN_STATUS_IF_FALSE(env, condition, status)                  \
+  do {                                                                  \
+    if (!(condition)) {                                                 \
+      return napi_set_last_error((env), (status));                      \
+    }                                                                   \
+  } while (0)
+
+#define CHECK_ENV(env)                                               \
+  if ((env) == nullptr) {                                            \
+    node::FatalError(__func__, "environment(env) must not be null"); \
+  }
+
+#define CHECK_ARG(env, arg) \
+  RETURN_STATUS_IF_FALSE((env), ((arg) != nullptr), napi_invalid_arg)
+
+#define CHECK_MAYBE_EMPTY(env, maybe, status) \
+  RETURN_STATUS_IF_FALSE((env), !((maybe).IsEmpty()), (status))
+
+#define CHECK_MAYBE_NOTHING(env, maybe, status) \
+  RETURN_STATUS_IF_FALSE((env), !((maybe).IsNothing()), (status))
+
+// NAPI_PREAMBLE is not wrapped in do..while: try_catch must have function scope
+#define NAPI_PREAMBLE(env)                                       \
+  CHECK_ENV((env));                                              \
+  RETURN_STATUS_IF_FALSE((env), (env)->last_exception.IsEmpty(), \
+                         napi_pending_exception);                \
+  napi_clear_last_error((env));                                  \
+  v8impl::TryCatch try_catch((env))
+
+#define CHECK_TO_TYPE(env, type, context, result, src, status)                \
+  do {                                                                        \
+    auto maybe = v8impl::V8LocalValueFromJsValue((src))->To##type((context)); \
+    CHECK_MAYBE_EMPTY((env), maybe, (status));                                \
+    (result) = maybe.ToLocalChecked();                                        \
+  } while (0)
+
+#define CHECK_TO_OBJECT(env, context, result, src) \
+  CHECK_TO_TYPE((env), Object, (context), (result), (src), napi_object_expected)
+
+#define CHECK_TO_STRING(env, context, result, src) \
+  CHECK_TO_TYPE((env), String, (context), (result), (src), napi_string_expected)
+
+#define CHECK_TO_NUMBER(env, context, result, src) \
+  CHECK_TO_TYPE((env), Number, (context), (result), (src), napi_number_expected)
+
+#define CHECK_TO_BOOL(env, context, result, src)            \
+  CHECK_TO_TYPE((env), Boolean, (context), (result), (src), \
+    napi_boolean_expected)
+
+#define CHECK_NEW_FROM_UTF8_LEN(env, result, str, len)                   \
+  do {                                                                   \
+    auto str_maybe = v8::String::NewFromUtf8(                            \
+        (env)->isolate, (str), v8::NewStringType::kInternalized, (len)); \
+    CHECK_MAYBE_EMPTY((env), str_maybe, napi_generic_failure);           \
+    (result) = str_maybe.ToLocalChecked();                               \
+  } while (0)
+
+#define CHECK_NEW_FROM_UTF8(env, result, str) \
+  CHECK_NEW_FROM_UTF8_LEN((env), (result), (str), -1)
+
+#define GET_RETURN_STATUS(env)      \
+  (!try_catch.HasCaught() ? napi_ok \
+                         : napi_set_last_error((env), napi_pending_exception))
+
 namespace v8impl {
 
 // convert from n-api property attributes to v8::PropertyAttribute
@@ -129,6 +193,22 @@ v8::Local<v8::Value> V8LocalValueFromJsValue(napi_value v) {
   return local;
 }
 
+static inline napi_status V8NameFromPropertyDescriptor(napi_env env,
+                                         const napi_property_descriptor* p,
+                                         v8::Local<v8::Name>* result) {
+  if (p->utf8name != nullptr) {
+    CHECK_NEW_FROM_UTF8(env, *result, p->utf8name);
+  } else {
+    v8::Local<v8::Value> property_value =
+      v8impl::V8LocalValueFromJsValue(p->name);
+
+    RETURN_STATUS_IF_FALSE(env, property_value->IsName(), napi_name_expected);
+    *result = property_value.As<v8::Name>();
+  }
+
+  return napi_ok;
+}
+
 // Adapter for napi_finalize callbacks.
 class Finalizer {
  protected:
@@ -363,13 +443,19 @@ class CallbackWrapperBase : public CallbackWrapper {
         v8::Local<v8::External>::Cast(
             _cbdata->GetInternalField(kInternalFieldIndex))->Value());
     v8::Isolate* isolate = _cbinfo.GetIsolate();
+
     napi_env env = static_cast<napi_env>(
         v8::Local<v8::External>::Cast(
             _cbdata->GetInternalField(kEnvIndex))->Value());
 
     // Make sure any errors encountered last time we were in N-API are gone.
     napi_clear_last_error(env);
-    cb(env, cbinfo_wrapper);
+
+    napi_value result = cb(env, cbinfo_wrapper);
+
+    if (result != nullptr) {
+      this->SetReturnValue(result);
+    }
 
     if (!env->last_exception.IsEmpty()) {
       isolate->ThrowException(
@@ -610,75 +696,12 @@ void napi_module_register(napi_module* mod) {
   node::node_module_register(nm);
 }
 
-#define RETURN_STATUS_IF_FALSE(env, condition, status)                  \
-  do {                                                                  \
-    if (!(condition)) {                                                 \
-      return napi_set_last_error((env), (status));                      \
-    }                                                                   \
-  } while (0)
-
-#define CHECK_ENV(env)                                               \
-  if ((env) == nullptr) {                                            \
-    node::FatalError(__func__, "environment(env) must not be null"); \
-  }
-
-#define CHECK_ARG(env, arg) \
-  RETURN_STATUS_IF_FALSE((env), ((arg) != nullptr), napi_invalid_arg)
-
-#define CHECK_MAYBE_EMPTY(env, maybe, status) \
-  RETURN_STATUS_IF_FALSE((env), !((maybe).IsEmpty()), (status))
-
-#define CHECK_MAYBE_NOTHING(env, maybe, status) \
-  RETURN_STATUS_IF_FALSE((env), !((maybe).IsNothing()), (status))
-
-// NAPI_PREAMBLE is not wrapped in do..while: try_catch must have function scope
-#define NAPI_PREAMBLE(env)                                       \
-  CHECK_ENV((env));                                              \
-  RETURN_STATUS_IF_FALSE((env), (env)->last_exception.IsEmpty(), \
-                         napi_pending_exception);                \
-  napi_clear_last_error((env));                                  \
-  v8impl::TryCatch try_catch((env))
-
-#define CHECK_TO_TYPE(env, type, context, result, src, status)                \
-  do {                                                                        \
-    auto maybe = v8impl::V8LocalValueFromJsValue((src))->To##type((context)); \
-    CHECK_MAYBE_EMPTY((env), maybe, (status));                                \
-    (result) = maybe.ToLocalChecked();                                        \
-  } while (0)
-
-#define CHECK_TO_OBJECT(env, context, result, src) \
-  CHECK_TO_TYPE((env), Object, (context), (result), (src), napi_object_expected)
-
-#define CHECK_TO_STRING(env, context, result, src) \
-  CHECK_TO_TYPE((env), String, (context), (result), (src), napi_string_expected)
-
-#define CHECK_TO_NUMBER(env, context, result, src) \
-  CHECK_TO_TYPE((env), Number, (context), (result), (src), napi_number_expected)
-
-#define CHECK_TO_BOOL(env, context, result, src)            \
-  CHECK_TO_TYPE((env), Boolean, (context), (result), (src), \
-    napi_boolean_expected)
-
-#define CHECK_NEW_FROM_UTF8_LEN(env, result, str, len)                   \
-  do {                                                                   \
-    auto str_maybe = v8::String::NewFromUtf8(                            \
-        (env)->isolate, (str), v8::NewStringType::kInternalized, (len)); \
-    CHECK_MAYBE_EMPTY((env), str_maybe, napi_generic_failure);           \
-    result = str_maybe.ToLocalChecked();                                 \
-  } while (0)
-
-#define CHECK_NEW_FROM_UTF8(env, result, str) \
-  CHECK_NEW_FROM_UTF8_LEN((env), (result), (str), -1)
-
-#define GET_RETURN_STATUS(env)      \
-  (!try_catch.HasCaught() ? napi_ok \
-                         : napi_set_last_error((env), napi_pending_exception))
-
 // Warning: Keep in-sync with napi_status enum
 const char* error_messages[] = {nullptr,
                                 "Invalid pointer passed as argument",
                                 "An object was expected",
                                 "A string was expected",
+                                "A string or symbol was expected",
                                 "A function was expected",
                                 "A number was expected",
                                 "A boolean was expected",
@@ -795,8 +818,14 @@ napi_status napi_define_class(napi_env env,
       continue;
     }
 
-    v8::Local<v8::String> property_name;
-    CHECK_NEW_FROM_UTF8(env, property_name, p->utf8name);
+    v8::Local<v8::Name> property_name;
+    napi_status status =
+        v8impl::V8NameFromPropertyDescriptor(env, p, &property_name);
+
+    if (status != napi_ok) {
+      return napi_set_last_error(env, status);
+    }
+
     v8::PropertyAttribute attributes =
         v8impl::V8PropertyAttributesFromDescriptor(p);
 
@@ -824,7 +853,6 @@ napi_status napi_define_class(napi_env env,
           v8impl::FunctionCallbackWrapper::Invoke,
           cbdata,
           v8::Signature::New(isolate, tpl));
-      t->SetClassName(property_name);
 
       tpl->PrototypeTemplate()->Set(property_name, t, attributes);
     } else {
@@ -857,18 +885,6 @@ napi_status napi_define_class(napi_env env,
   return GET_RETURN_STATUS(env);
 }
 
-napi_status napi_set_return_value(napi_env env,
-                                  napi_callback_info cbinfo,
-                                  napi_value value) {
-  NAPI_PREAMBLE(env);
-
-  v8impl::CallbackWrapper* info =
-      reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
-
-  info->SetReturnValue(value);
-  return GET_RETURN_STATUS(env);
-}
-
 napi_status napi_get_property_names(napi_env env,
                                     napi_value object,
                                     napi_value* result) {
@@ -1104,11 +1120,16 @@ napi_status napi_define_properties(napi_env env,
   for (size_t i = 0; i < property_count; i++) {
     const napi_property_descriptor* p = &properties[i];
 
-    v8::Local<v8::Name> name;
-    CHECK_NEW_FROM_UTF8(env, name, p->utf8name);
+    v8::Local<v8::Name> property_name;
+    napi_status status =
+        v8impl::V8NameFromPropertyDescriptor(env, p, &property_name);
+
+    if (status != napi_ok) {
+      return napi_set_last_error(env, status);
+    }
 
     v8::PropertyAttribute attributes =
-          v8impl::V8PropertyAttributesFromDescriptor(p);
+        v8impl::V8PropertyAttributesFromDescriptor(p);
 
     if (p->getter != nullptr || p->setter != nullptr) {
       v8::Local<v8::Object> cbdata = v8impl::CreateAccessorCallbackData(
@@ -1119,7 +1140,7 @@ napi_status napi_define_properties(napi_env env,
 
       auto set_maybe = obj->SetAccessor(
         context,
-        name,
+        property_name,
         p->getter ? v8impl::GetterCallbackWrapper::Invoke : nullptr,
         p->setter ? v8impl::SetterCallbackWrapper::Invoke : nullptr,
         cbdata,
@@ -1138,8 +1159,8 @@ napi_status napi_define_properties(napi_env env,
       v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(
           isolate, v8impl::FunctionCallbackWrapper::Invoke, cbdata);
 
-      auto define_maybe =
-          obj->DefineOwnProperty(context, name, t->GetFunction(), attributes);
+      auto define_maybe = obj->DefineOwnProperty(
+        context, property_name, t->GetFunction(), attributes);
 
       if (!define_maybe.FromMaybe(false)) {
         return napi_set_last_error(env, napi_generic_failure);
@@ -1148,7 +1169,7 @@ napi_status napi_define_properties(napi_env env,
       v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(p->value);
 
       auto define_maybe =
-          obj->DefineOwnProperty(context, name, value, attributes);
+          obj->DefineOwnProperty(context, property_name, value, attributes);
 
       if (!define_maybe.FromMaybe(false)) {
         return napi_set_last_error(env, napi_invalid_arg);
@@ -1441,33 +1462,24 @@ napi_status napi_get_cb_info(
     napi_value* this_arg,  // [out] Receives the JS 'this' arg for the call
     void** data) {         // [out] Receives the data pointer for the callback.
   CHECK_ENV(env);
-  CHECK_ARG(env, argc);
-  CHECK_ARG(env, argv);
-  CHECK_ARG(env, this_arg);
-  CHECK_ARG(env, data);
 
   v8impl::CallbackWrapper* info =
       reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
 
-  info->Args(argv, std::min(*argc, info->ArgsLength()));
-  *argc = info->ArgsLength();
-  *this_arg = info->This();
-  *data = info->Data();
-
-  return napi_ok;
-}
-
-napi_status napi_get_cb_args_length(napi_env env,
-                                    napi_callback_info cbinfo,
-                                    size_t* result) {
-  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because no V8 APIs are called.
-  CHECK_ENV(env);
-  CHECK_ARG(env, result);
-
-  v8impl::CallbackWrapper* info =
-      reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
+  if (argv != nullptr) {
+    CHECK_ARG(env, argc);
+    info->Args(argv, std::min(*argc, info->ArgsLength()));
+  }
+  if (argc != nullptr) {
+    *argc = info->ArgsLength();
+  }
+  if (this_arg != nullptr) {
+    *this_arg = info->This();
+  }
+  if (data != nullptr) {
+    *data = info->Data();
+  }
 
-  *result = info->ArgsLength();
   return napi_ok;
 }
 
@@ -1485,51 +1497,6 @@ napi_status napi_is_construct_call(napi_env env,
   return napi_ok;
 }
 
-// copy encoded arguments into provided buffer or return direct pointer to
-// encoded arguments array?
-napi_status napi_get_cb_args(napi_env env,
-                             napi_callback_info cbinfo,
-                             napi_value* buf,
-                             size_t bufsize) {
-  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because no V8 APIs are called.
-  CHECK_ENV(env);
-  CHECK_ARG(env, buf);
-
-  v8impl::CallbackWrapper* info =
-      reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
-
-  info->Args(buf, bufsize);
-  return napi_ok;
-}
-
-napi_status napi_get_cb_this(napi_env env,
-                             napi_callback_info cbinfo,
-                             napi_value* result) {
-  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because no V8 APIs are called.
-  CHECK_ENV(env);
-  CHECK_ARG(env, result);
-
-  v8impl::CallbackWrapper* info =
-      reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
-
-  *result = info->This();
-  return napi_ok;
-}
-
-napi_status napi_get_cb_data(napi_env env,
-                             napi_callback_info cbinfo,
-                             void** result) {
-  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because no V8 APIs are called.
-  CHECK_ENV(env);
-  CHECK_ARG(env, result);
-
-  v8impl::CallbackWrapper* info =
-      reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
-
-  *result = info->Data();
-  return napi_ok;
-}
-
 napi_status napi_call_function(napi_env env,
                                napi_value recv,
                                napi_value func,
diff --git a/src/node_api.h b/src/node_api.h
index da14a01654b844..c232d9aa039d13 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -298,29 +298,12 @@ NAPI_EXTERN napi_status napi_get_cb_info(
     size_t* argc,      // [in-out] Specifies the size of the provided argv array
                        // and receives the actual count of args.
     napi_value* argv,  // [out] Array of values
-    napi_value* thisArg,  // [out] Receives the JS 'this' arg for the call
-    void** data);         // [out] Receives the data pointer for the callback.
-
-NAPI_EXTERN napi_status napi_get_cb_args_length(napi_env env,
-                                                napi_callback_info cbinfo,
-                                                size_t* result);
-NAPI_EXTERN napi_status napi_get_cb_args(napi_env env,
-                                         napi_callback_info cbinfo,
-                                         napi_value* buf,
-                                         size_t bufsize);
-NAPI_EXTERN napi_status napi_get_cb_this(napi_env env,
-                                         napi_callback_info cbinfo,
-                                         napi_value* result);
+    napi_value* this_arg,  // [out] Receives the JS 'this' arg for the call
+    void** data);          // [out] Receives the data pointer for the callback.
 
-NAPI_EXTERN napi_status napi_get_cb_data(napi_env env,
-                                         napi_callback_info cbinfo,
-                                         void** result);
 NAPI_EXTERN napi_status napi_is_construct_call(napi_env env,
                                                napi_callback_info cbinfo,
                                                bool* result);
-NAPI_EXTERN napi_status napi_set_return_value(napi_env env,
-                                              napi_callback_info cbinfo,
-                                              napi_value value);
 NAPI_EXTERN napi_status
 napi_define_class(napi_env env,
                   const char* utf8name,
diff --git a/src/node_api_types.h b/src/node_api_types.h
index f3f3faaa641cbb..f439cce1f9003b 100644
--- a/src/node_api_types.h
+++ b/src/node_api_types.h
@@ -17,8 +17,8 @@ typedef struct napi_handle_scope__ *napi_handle_scope;
 typedef struct napi_escapable_handle_scope__ *napi_escapable_handle_scope;
 typedef struct napi_callback_info__ *napi_callback_info;
 
-typedef void (*napi_callback)(napi_env env,
-                              napi_callback_info info);
+typedef napi_value (*napi_callback)(napi_env env,
+                                    napi_callback_info info);
 typedef void (*napi_finalize)(napi_env env,
                               void* finalize_data,
                               void* finalize_hint);
@@ -35,7 +35,9 @@ typedef enum {
 } napi_property_attributes;
 
 typedef struct {
+  // One of utf8name or name should be NULL.
   const char* utf8name;
+  napi_value name;
 
   napi_callback method;
   napi_callback getter;
@@ -76,6 +78,7 @@ typedef enum {
   napi_invalid_arg,
   napi_object_expected,
   napi_string_expected,
+  napi_name_expected,
   napi_function_expected,
   napi_number_expected,
   napi_boolean_expected,
diff --git a/test/addons-napi/1_hello_world/binding.c b/test/addons-napi/1_hello_world/binding.c
index 882508b9548926..57bac37fa0bfd1 100644
--- a/test/addons-napi/1_hello_world/binding.c
+++ b/test/addons-napi/1_hello_world/binding.c
@@ -1,22 +1,18 @@
 #include <node_api.h>
+#include "../common.h"
+#include <string.h>
 
-void Method(napi_env env, napi_callback_info info) {
-  napi_status status;
+napi_value Method(napi_env env, napi_callback_info info) {
   napi_value world;
-  status = napi_create_string_utf8(env, "world", -1, &world);
-  if (status != napi_ok) return;
-  status = napi_set_return_value(env, info, world);
-  if (status != napi_ok) return;
+  const char* str = "world";
+  size_t str_len = strlen(str);
+  NAPI_CALL(env, napi_create_string_utf8(env, str, str_len, &world));
+  return world;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
-  napi_property_descriptor desc = DECLARE_NAPI_METHOD("hello", Method);
-  status = napi_define_properties(env, exports, 1, &desc);
-  if (status != napi_ok) return;
+  napi_property_descriptor desc = DECLARE_NAPI_PROPERTY("hello", Method);
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(env, exports, 1, &desc));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/2_function_arguments/binding.c b/test/addons-napi/2_function_arguments/binding.c
index bdc25a235c3ce5..a5ccac7b61c458 100644
--- a/test/addons-napi/2_function_arguments/binding.c
+++ b/test/addons-napi/2_function_arguments/binding.c
@@ -1,58 +1,37 @@
 #include <node_api.h>
+#include "../common.h"
 
-void Add(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
-
-  if (argc < 2) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
-
+napi_value Add(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
   napi_value args[2];
-  status = napi_get_cb_args(env, info, args, 2);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 2, "Wrong number of arguments");
 
   napi_valuetype valuetype0;
-  status = napi_typeof(env, args[0], &valuetype0);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
   napi_valuetype valuetype1;
-  status = napi_typeof(env, args[1], &valuetype1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
 
-  if (valuetype0 != napi_number || valuetype1 != napi_number) {
-    napi_throw_type_error(env, "Wrong arguments");
-    return;
-  }
+  NAPI_ASSERT(env, valuetype0 == napi_number && valuetype1 == napi_number,
+    "Wrong argument type. Numbers expected.");
 
   double value0;
-  status = napi_get_value_double(env, args[0], &value0);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_value_double(env, args[0], &value0));
 
   double value1;
-  status = napi_get_value_double(env, args[1], &value1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_value_double(env, args[1], &value1));
 
   napi_value sum;
-  status = napi_create_number(env, value0 + value1, &sum);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_number(env, value0 + value1, &sum));
 
-  status = napi_set_return_value(env, info, sum);
-  if (status != napi_ok) return;
+  return sum;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
-  napi_property_descriptor addDescriptor = DECLARE_NAPI_METHOD("add", Add);
-  status = napi_define_properties(env, exports, 1, &addDescriptor);
-  if (status != napi_ok) return;
+  napi_property_descriptor desc = DECLARE_NAPI_PROPERTY("add", Add);
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(env, exports, 1, &desc));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/3_callbacks/binding.c b/test/addons-napi/3_callbacks/binding.c
index 10e7318bcecb40..47360bd979ffc4 100644
--- a/test/addons-napi/3_callbacks/binding.c
+++ b/test/addons-napi/3_callbacks/binding.c
@@ -1,51 +1,43 @@
 #include <node_api.h>
+#include "../common.h"
+#include <string.h>
 
-#define NAPI_CALL(env, theCall)                                                \
-  if ((theCall) != napi_ok) {                                                  \
-    const napi_extended_error_info* error;                                     \
-    napi_get_last_error_info((env), &error);                                   \
-    const char* errorMessage = error->error_message;                           \
-    errorMessage = errorMessage ? errorMessage : "empty error message";        \
-    napi_throw_error((env), errorMessage);                                     \
-    return;                                                                    \
-  }
-
-void RunCallback(napi_env env, napi_callback_info info) {
+napi_value RunCallback(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
   napi_value args[1];
-  NAPI_CALL(env, napi_get_cb_args(env, info, args, 1));
-
-  napi_value cb = args[0];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   napi_value argv[1];
-  NAPI_CALL(env, napi_create_string_utf8(env, "hello world", -1, argv));
+  const char* str = "hello world";
+  size_t str_len = strlen(str);
+  NAPI_CALL(env, napi_create_string_utf8(env, str, str_len, argv));
 
   napi_value global;
   NAPI_CALL(env, napi_get_global(env, &global));
 
+  napi_value cb = args[0];
   NAPI_CALL(env, napi_call_function(env, global, cb, 1, argv, NULL));
+
+  return NULL;
 }
 
-void RunCallbackWithRecv(napi_env env, napi_callback_info info) {
+napi_value RunCallbackWithRecv(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
   napi_value args[2];
-  NAPI_CALL(env, napi_get_cb_args(env, info, args, 2));
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   napi_value cb = args[0];
   napi_value recv = args[1];
-
   NAPI_CALL(env, napi_call_function(env, recv, cb, 0, NULL, NULL));
+  return NULL;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
   napi_property_descriptor desc[2] = {
-      DECLARE_NAPI_METHOD("RunCallback", RunCallback),
-      DECLARE_NAPI_METHOD("RunCallbackWithRecv", RunCallbackWithRecv),
+    DECLARE_NAPI_PROPERTY("RunCallback", RunCallback),
+    DECLARE_NAPI_PROPERTY("RunCallbackWithRecv", RunCallbackWithRecv),
   };
-  status = napi_define_properties(env, exports, 2, desc);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(env, exports, 2, desc));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/4_object_factory/binding.c b/test/addons-napi/4_object_factory/binding.c
index 0d9902259fe220..d76f30b847a237 100644
--- a/test/addons-napi/4_object_factory/binding.c
+++ b/test/addons-napi/4_object_factory/binding.c
@@ -1,31 +1,23 @@
 #include <node_api.h>
+#include "../common.h"
 
-void CreateObject(napi_env env, napi_callback_info info) {
-  napi_status status;
-
+napi_value CreateObject(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
   napi_value args[1];
-  status = napi_get_cb_args(env, info, args, 1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   napi_value obj;
-  status = napi_create_object(env, &obj);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_object(env, &obj));
 
-  status = napi_set_named_property(env, obj, "msg", args[0]);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_set_named_property(env, obj, "msg", args[0]));
 
-  status = napi_set_return_value(env, info, obj);
-  if (status != napi_ok) return;
+  return obj;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
-  napi_property_descriptor desc = DECLARE_NAPI_METHOD("exports", CreateObject);
-  status = napi_define_properties(env, module, 1, &desc);
-  if (status != napi_ok) return;
+  napi_property_descriptor desc =
+    DECLARE_NAPI_PROPERTY("exports", CreateObject);
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(env, module, 1, &desc));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/5_function_factory/binding.c b/test/addons-napi/5_function_factory/binding.c
index 867a527ee97c64..4c20190f5047cd 100644
--- a/test/addons-napi/5_function_factory/binding.c
+++ b/test/addons-napi/5_function_factory/binding.c
@@ -1,36 +1,25 @@
 #include <node_api.h>
+#include "../common.h"
 
-void MyFunction(napi_env env, napi_callback_info info) {
-  napi_status status;
-
+napi_value MyFunction(napi_env env, napi_callback_info info) {
   napi_value str;
-  status = napi_create_string_utf8(env, "hello world", -1, &str);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_string_utf8(env, "hello world", -1, &str));
 
-  status = napi_set_return_value(env, info, str);
-  if (status != napi_ok) return;
+  return str;
 }
 
-void CreateFunction(napi_env env, napi_callback_info info) {
-  napi_status status;
-
+napi_value CreateFunction(napi_env env, napi_callback_info info) {
   napi_value fn;
-  status = napi_create_function(env, "theFunction", MyFunction, NULL, &fn);
-  if (status != napi_ok) return;
+  NAPI_CALL(env,
+    napi_create_function(env, "theFunction", MyFunction, NULL, &fn));
 
-  status = napi_set_return_value(env, info, fn);
-  if (status != napi_ok) return;
+  return fn;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
   napi_property_descriptor desc =
-      DECLARE_NAPI_METHOD("exports", CreateFunction);
-  status = napi_define_properties(env, module, 1, &desc);
-  if (status != napi_ok) return;
+    DECLARE_NAPI_PROPERTY("exports", CreateFunction);
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(env, module, 1, &desc));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/6_object_wrap/myobject.cc b/test/addons-napi/6_object_wrap/myobject.cc
index 67521ae3132fc6..c2557facc06382 100644
--- a/test/addons-napi/6_object_wrap/myobject.cc
+++ b/test/addons-napi/6_object_wrap/myobject.cc
@@ -1,4 +1,5 @@
 #include "myobject.h"
+#include "../common.h"
 
 napi_ref MyObject::constructor;
 
@@ -13,189 +14,136 @@ void MyObject::Destructor(
   delete obj;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 void MyObject::Init(napi_env env, napi_value exports) {
-  napi_status status;
   napi_property_descriptor properties[] = {
-      { "value", nullptr, GetValue, SetValue, 0, napi_default, 0 },
-      DECLARE_NAPI_METHOD("plusOne", PlusOne),
-      DECLARE_NAPI_METHOD("multiply", Multiply),
+    { "value", nullptr, nullptr, GetValue, SetValue, 0, napi_default, 0 },
+    DECLARE_NAPI_PROPERTY("plusOne", PlusOne),
+    DECLARE_NAPI_PROPERTY("multiply", Multiply),
   };
 
   napi_value cons;
-  status =
-      napi_define_class(env, "MyObject", New, nullptr, 3, properties, &cons);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env,
+    napi_define_class(env, "MyObject", New, nullptr, 3, properties, &cons));
 
-  status = napi_create_reference(env, cons, 1, &constructor);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_create_reference(env, cons, 1, &constructor));
 
-  status = napi_set_named_property(env, exports, "MyObject", cons);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env,
+    napi_set_named_property(env, exports, "MyObject", cons));
 }
 
-void MyObject::New(napi_env env, napi_callback_info info) {
-  napi_status status;
-
+napi_value MyObject::New(napi_env env, napi_callback_info info) {
   bool is_constructor;
-  status = napi_is_construct_call(env, info, &is_constructor);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_is_construct_call(env, info, &is_constructor));
+
+  size_t argc = 1;
+  napi_value args[1];
+  napi_value _this;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &_this, nullptr));
 
   if (is_constructor) {
     // Invoked as constructor: `new MyObject(...)`
-    napi_value args[1];
-    status = napi_get_cb_args(env, info, args, 1);
-    if (status != napi_ok) return;
-
     double value = 0;
 
     napi_valuetype valuetype;
-    status = napi_typeof(env, args[0], &valuetype);
-    if (status != napi_ok) return;
+    NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
     if (valuetype != napi_undefined) {
-      status = napi_get_value_double(env, args[0], &value);
-      if (status != napi_ok) return;
+      NAPI_CALL(env, napi_get_value_double(env, args[0], &value));
     }
 
     MyObject* obj = new MyObject(value);
 
-    napi_value jsthis;
-    status = napi_get_cb_this(env, info, &jsthis);
-    if (status != napi_ok) return;
-
     obj->env_ = env;
-    status = napi_wrap(env,
-                       jsthis,
-                       obj,
-                       MyObject::Destructor,
-                       nullptr,  // finalize_hint
-                       &obj->wrapper_);
-    if (status != napi_ok) return;
-
-    status = napi_set_return_value(env, info, jsthis);
-    if (status != napi_ok) return;
-  } else {
-    // Invoked as plain function `MyObject(...)`, turn into construct call.
-    napi_value args[1];
-    status = napi_get_cb_args(env, info, args, 1);
-    if (status != napi_ok) return;
-
-    const int argc = 1;
-    napi_value argv[argc] = {args[0]};
-
-    napi_value cons;
-    status = napi_get_reference_value(env, constructor, &cons);
-    if (status != napi_ok) return;
-
-    napi_value instance;
-    status = napi_new_instance(env, cons, argc, argv, &instance);
-    if (status != napi_ok) return;
-
-    status = napi_set_return_value(env, info, instance);
-    if (status != napi_ok) return;
+    NAPI_CALL(env, napi_wrap(env,
+                            _this,
+                            obj,
+                            MyObject::Destructor,
+                            nullptr,  // finalize_hint
+                            &obj->wrapper_));
+
+    return _this;
   }
-}
 
-void MyObject::GetValue(napi_env env, napi_callback_info info) {
-  napi_status status;
+  // Invoked as plain function `MyObject(...)`, turn into construct call.
+  argc = 1;
+  napi_value argv[1] = {args[0]};
 
-  napi_value jsthis;
-  status = napi_get_cb_this(env, info, &jsthis);
-  if (status != napi_ok) return;
+  napi_value cons;
+  NAPI_CALL(env, napi_get_reference_value(env, constructor, &cons));
+
+  napi_value instance;
+  NAPI_CALL(env, napi_new_instance(env, cons, argc, argv, &instance));
+
+  return instance;
+}
+
+napi_value MyObject::GetValue(napi_env env, napi_callback_info info) {
+  napi_value _this;
+  NAPI_CALL(env,
+    napi_get_cb_info(env, info, nullptr, nullptr, &_this, nullptr));
 
   MyObject* obj;
-  status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_unwrap(env, _this, reinterpret_cast<void**>(&obj)));
 
   napi_value num;
-  status = napi_create_number(env, obj->value_, &num);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_number(env, obj->value_, &num));
 
-  status = napi_set_return_value(env, info, num);
-  if (status != napi_ok) return;
+  return num;
 }
 
-void MyObject::SetValue(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  napi_value value;
-  status = napi_get_cb_args(env, info, &value, 1);
-  if (status != napi_ok) return;
-
-  napi_value jsthis;
-  status = napi_get_cb_this(env, info, &jsthis);
-  if (status != napi_ok) return;
+napi_value MyObject::SetValue(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  napi_value _this;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &_this, nullptr));
 
   MyObject* obj;
-  status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_unwrap(env, _this, reinterpret_cast<void**>(&obj)));
 
-  status = napi_get_value_double(env, value, &obj->value_);
-  if (status != napi_ok) return;
-}
+  NAPI_CALL(env, napi_get_value_double(env, args[0], &obj->value_));
 
-void MyObject::PlusOne(napi_env env, napi_callback_info info) {
-  napi_status status;
+  return nullptr;
+}
 
-  napi_value jsthis;
-  status = napi_get_cb_this(env, info, &jsthis);
-  if (status != napi_ok) return;
+napi_value MyObject::PlusOne(napi_env env, napi_callback_info info) {
+  napi_value _this;
+  NAPI_CALL(env,
+    napi_get_cb_info(env, info, nullptr, nullptr, &_this, nullptr));
 
   MyObject* obj;
-  status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_unwrap(env, _this, reinterpret_cast<void**>(&obj)));
 
   obj->value_ += 1;
 
   napi_value num;
-  status = napi_create_number(env, obj->value_, &num);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_number(env, obj->value_, &num));
 
-  status = napi_set_return_value(env, info, num);
-  if (status != napi_ok) return;
+  return num;
 }
 
-void MyObject::Multiply(napi_env env, napi_callback_info info) {
-  napi_status status;
-
+napi_value MyObject::Multiply(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
   napi_value args[1];
-  status = napi_get_cb_args(env, info, args, 1);
-  if (status != napi_ok) return;
-
-  napi_valuetype valuetype;
-  status = napi_typeof(env, args[0], &valuetype);
-  if (status != napi_ok) return;
+  napi_value _this;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &_this, nullptr));
 
   double multiple = 1;
-  if (valuetype != napi_undefined) {
-    status = napi_get_value_double(env, args[0], &multiple);
-    if (status != napi_ok) return;
+  if (argc >= 1) {
+    NAPI_CALL(env, napi_get_value_double(env, args[0], &multiple));
   }
 
-  napi_value jsthis;
-  status = napi_get_cb_this(env, info, &jsthis);
-  if (status != napi_ok) return;
-
   MyObject* obj;
-  status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_unwrap(env, _this, reinterpret_cast<void**>(&obj)));
 
   napi_value cons;
-  status = napi_get_reference_value(env, constructor, &cons);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_reference_value(env, constructor, &cons));
 
   const int kArgCount = 1;
   napi_value argv[kArgCount];
-  status = napi_create_number(env, obj->value_ * multiple, argv);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_number(env, obj->value_ * multiple, argv));
 
   napi_value instance;
-  status = napi_new_instance(env, cons, kArgCount, argv, &instance);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_new_instance(env, cons, kArgCount, argv, &instance));
 
-  status = napi_set_return_value(env, info, instance);
-  if (status != napi_ok) return;
+  return instance;
 }
diff --git a/test/addons-napi/6_object_wrap/myobject.h b/test/addons-napi/6_object_wrap/myobject.h
index 2c8f47753769f5..b7f425951dda7f 100644
--- a/test/addons-napi/6_object_wrap/myobject.h
+++ b/test/addons-napi/6_object_wrap/myobject.h
@@ -12,11 +12,11 @@ class MyObject {
   explicit MyObject(double value_ = 0);
   ~MyObject();
 
-  static void New(napi_env env, napi_callback_info info);
-  static void GetValue(napi_env env, napi_callback_info info);
-  static void SetValue(napi_env env, napi_callback_info info);
-  static void PlusOne(napi_env env, napi_callback_info info);
-  static void Multiply(napi_env env, napi_callback_info info);
+  static napi_value New(napi_env env, napi_callback_info info);
+  static napi_value GetValue(napi_env env, napi_callback_info info);
+  static napi_value SetValue(napi_env env, napi_callback_info info);
+  static napi_value PlusOne(napi_env env, napi_callback_info info);
+  static napi_value Multiply(napi_env env, napi_callback_info info);
   static napi_ref constructor;
   double value_;
   napi_env env_;
diff --git a/test/addons-napi/7_factory_wrap/binding.cc b/test/addons-napi/7_factory_wrap/binding.cc
index 0aede8cbb8c201..c61e4094784ed7 100644
--- a/test/addons-napi/7_factory_wrap/binding.cc
+++ b/test/addons-napi/7_factory_wrap/binding.cc
@@ -1,32 +1,23 @@
 #include "myobject.h"
+#include "../common.h"
 
-void CreateObject(napi_env env, napi_callback_info info) {
-  napi_status status;
-
+napi_value CreateObject(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
   napi_value args[1];
-  status = napi_get_cb_args(env, info, args, 1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
 
   napi_value instance;
-  status = MyObject::NewInstance(env, args[0], &instance);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, MyObject::NewInstance(env, args[0], &instance));
 
-  status = napi_set_return_value(env, info, instance);
-  if (status != napi_ok) return;
+  return instance;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
-
-  status = MyObject::Init(env);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, MyObject::Init(env));
 
-  napi_property_descriptor desc = DECLARE_NAPI_METHOD("exports", CreateObject);
-  status = napi_define_properties(env, module, 1, &desc);
-  if (status != napi_ok) return;
+  napi_property_descriptor desc =
+    DECLARE_NAPI_PROPERTY("exports", CreateObject);
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(env, module, 1, &desc));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/7_factory_wrap/myobject.cc b/test/addons-napi/7_factory_wrap/myobject.cc
index a3fbf6f9ecf1d5..d6b374d7bb7ff8 100644
--- a/test/addons-napi/7_factory_wrap/myobject.cc
+++ b/test/addons-napi/7_factory_wrap/myobject.cc
@@ -1,4 +1,5 @@
 #include "myobject.h"
+#include "../common.h"
 
 MyObject::MyObject() : env_(nullptr), wrapper_(nullptr) {}
 
@@ -11,15 +12,12 @@ void MyObject::Destructor(napi_env env,
   delete obj;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 napi_ref MyObject::constructor;
 
 napi_status MyObject::Init(napi_env env) {
   napi_status status;
   napi_property_descriptor properties[] = {
-      DECLARE_NAPI_METHOD("plusOne", PlusOne),
+    DECLARE_NAPI_PROPERTY("plusOne", PlusOne),
   };
 
   napi_value cons;
@@ -33,41 +31,32 @@ napi_status MyObject::Init(napi_env env) {
   return napi_ok;
 }
 
-void MyObject::New(napi_env env, napi_callback_info info) {
-  napi_status status;
-
+napi_value MyObject::New(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
   napi_value args[1];
-  status = napi_get_cb_args(env, info, args, 1);
-  if (status != napi_ok) return;
+  napi_value _this;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &_this, nullptr));
 
   napi_valuetype valuetype;
-  status = napi_typeof(env, args[0], &valuetype);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
   MyObject* obj = new MyObject();
 
   if (valuetype == napi_undefined) {
     obj->counter_ = 0;
   } else {
-    status = napi_get_value_double(env, args[0], &obj->counter_);
-    if (status != napi_ok) return;
+    NAPI_CALL(env, napi_get_value_double(env, args[0], &obj->counter_));
   }
 
-  napi_value jsthis;
-  status = napi_get_cb_this(env, info, &jsthis);
-  if (status != napi_ok) return;
-
   obj->env_ = env;
-  status = napi_wrap(env,
-                     jsthis,
-                     obj,
-                     MyObject::Destructor,
-                     nullptr, /* finalize_hint */
-                     &obj->wrapper_);
-  if (status != napi_ok) return;
-
-  status = napi_set_return_value(env, info, jsthis);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_wrap(env,
+                          _this,
+                          obj,
+                          MyObject::Destructor,
+                          nullptr, /* finalize_hint */
+                          &obj->wrapper_));
+
+  return _this;
 }
 
 napi_status MyObject::NewInstance(napi_env env,
@@ -88,23 +77,18 @@ napi_status MyObject::NewInstance(napi_env env,
   return napi_ok;
 }
 
-void MyObject::PlusOne(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  napi_value jsthis;
-  status = napi_get_cb_this(env, info, &jsthis);
-  if (status != napi_ok) return;
+napi_value MyObject::PlusOne(napi_env env, napi_callback_info info) {
+  napi_value _this;
+  NAPI_CALL(env,
+    napi_get_cb_info(env, info, nullptr, nullptr, &_this, nullptr));
 
   MyObject* obj;
-  status = napi_unwrap(env, jsthis, reinterpret_cast<void**>(&obj));
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_unwrap(env, _this, reinterpret_cast<void**>(&obj)));
 
   obj->counter_ += 1;
 
   napi_value num;
-  status = napi_create_number(env, obj->counter_, &num);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_number(env, obj->counter_, &num));
 
-  status = napi_set_return_value(env, info, num);
-  if (status != napi_ok) return;
+  return num;
 }
diff --git a/test/addons-napi/7_factory_wrap/myobject.h b/test/addons-napi/7_factory_wrap/myobject.h
index 323079951e6633..c0b8522c609c4c 100644
--- a/test/addons-napi/7_factory_wrap/myobject.h
+++ b/test/addons-napi/7_factory_wrap/myobject.h
@@ -16,8 +16,8 @@ class MyObject {
   ~MyObject();
 
   static napi_ref constructor;
-  static void New(napi_env env, napi_callback_info info);
-  static void PlusOne(napi_env env, napi_callback_info info);
+  static napi_value New(napi_env env, napi_callback_info info);
+  static napi_value PlusOne(napi_env env, napi_callback_info info);
   double counter_;
   napi_env env_;
   napi_ref wrapper_;
diff --git a/test/addons-napi/8_passing_wrapped/binding.cc b/test/addons-napi/8_passing_wrapped/binding.cc
index d6a4eafd883a45..581638bdfa2b07 100644
--- a/test/addons-napi/8_passing_wrapped/binding.cc
+++ b/test/addons-napi/8_passing_wrapped/binding.cc
@@ -1,57 +1,44 @@
 #include "myobject.h"
+#include "../common.h"
 
-void CreateObject(napi_env env, napi_callback_info info) {
-  napi_status status;
-
+napi_value CreateObject(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
   napi_value args[1];
-  status = napi_get_cb_args(env, info, args, 1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
 
   napi_value instance;
-  status = MyObject::NewInstance(env, args[0], &instance);
+  NAPI_CALL(env, MyObject::NewInstance(env, args[0], &instance));
 
-  status = napi_set_return_value(env, info, instance);
-  if (status != napi_ok) return;
+  return instance;
 }
 
-void Add(napi_env env, napi_callback_info info) {
-  napi_status status;
-
+napi_value Add(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
   napi_value args[2];
-  status = napi_get_cb_args(env, info, args, 2);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
 
   MyObject* obj1;
-  status = napi_unwrap(env, args[0], reinterpret_cast<void**>(&obj1));
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_unwrap(env, args[0], reinterpret_cast<void**>(&obj1)));
 
   MyObject* obj2;
-  status = napi_unwrap(env, args[1], reinterpret_cast<void**>(&obj2));
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_unwrap(env, args[1], reinterpret_cast<void**>(&obj2)));
 
   napi_value sum;
-  status = napi_create_number(env, obj1->Val() + obj2->Val(), &sum);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_number(env, obj1->Val() + obj2->Val(), &sum));
 
-  status = napi_set_return_value(env, info, sum);
-  if (status != napi_ok) return;
+  return sum;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
-
   MyObject::Init(env);
 
   napi_property_descriptor desc[] = {
-      DECLARE_NAPI_METHOD("createObject", CreateObject),
-      DECLARE_NAPI_METHOD("add", Add),
+    DECLARE_NAPI_PROPERTY("createObject", CreateObject),
+    DECLARE_NAPI_PROPERTY("add", Add),
   };
-  status =
-      napi_define_properties(env, exports, sizeof(desc) / sizeof(*desc), desc);
-  if (status != napi_ok) return;
+
+  NAPI_CALL_RETURN_VOID(env,
+    napi_define_properties(env, exports, sizeof(desc) / sizeof(*desc), desc));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/8_passing_wrapped/myobject.cc b/test/addons-napi/8_passing_wrapped/myobject.cc
index 8bca17a3be39b8..0c24d7696e66ec 100644
--- a/test/addons-napi/8_passing_wrapped/myobject.cc
+++ b/test/addons-napi/8_passing_wrapped/myobject.cc
@@ -1,4 +1,5 @@
 #include "myobject.h"
+#include "../common.h"
 
 MyObject::MyObject() : env_(nullptr), wrapper_(nullptr) {}
 
@@ -25,41 +26,32 @@ napi_status MyObject::Init(napi_env env) {
   return napi_ok;
 }
 
-void MyObject::New(napi_env env, napi_callback_info info) {
-  napi_status status;
-
+napi_value MyObject::New(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
   napi_value args[1];
-  status = napi_get_cb_args(env, info, args, 1);
-  if (status != napi_ok) return;
+  napi_value _this;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, &_this, nullptr));
 
   MyObject* obj = new MyObject();
 
   napi_valuetype valuetype;
-  status = napi_typeof(env, args[0], &valuetype);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
   if (valuetype == napi_undefined) {
     obj->val_ = 0;
   } else {
-    status = napi_get_value_double(env, args[0], &obj->val_);
-    if (status != napi_ok) return;
+    NAPI_CALL(env, napi_get_value_double(env, args[0], &obj->val_));
   }
 
-  napi_value jsthis;
-  status = napi_get_cb_this(env, info, &jsthis);
-  if (status != napi_ok) return;
-
   obj->env_ = env;
-  status = napi_wrap(env,
-                     jsthis,
-                     obj,
-                     MyObject::Destructor,
-                     nullptr,  // finalize_hint
-                     &obj->wrapper_);
-  if (status != napi_ok) return;
-
-  status = napi_set_return_value(env, info, jsthis);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_wrap(env,
+                          _this,
+                          obj,
+                          MyObject::Destructor,
+                          nullptr,  // finalize_hint
+                          &obj->wrapper_));
+
+  return _this;
 }
 
 napi_status MyObject::NewInstance(napi_env env,
diff --git a/test/addons-napi/8_passing_wrapped/myobject.h b/test/addons-napi/8_passing_wrapped/myobject.h
index 773c86e04bba81..7c6a35aa853cc5 100644
--- a/test/addons-napi/8_passing_wrapped/myobject.h
+++ b/test/addons-napi/8_passing_wrapped/myobject.h
@@ -17,7 +17,7 @@ class MyObject {
   ~MyObject();
 
   static napi_ref constructor;
-  static void New(napi_env env, napi_callback_info info);
+  static napi_value New(napi_env env, napi_callback_info info);
   double val_;
   napi_env env_;
   napi_ref wrapper_;
diff --git a/test/addons-napi/common.h b/test/addons-napi/common.h
new file mode 100644
index 00000000000000..b06ece6e39c7d6
--- /dev/null
+++ b/test/addons-napi/common.h
@@ -0,0 +1,52 @@
+// Empty value so that macros here are able to return NULL or void
+#define NAPI_RETVAL_NOTHING  // Intentionally blank #define
+
+#define GET_AND_THROW_LAST_ERROR(env)                                    \
+  do {                                                                   \
+    bool is_pending;                                                     \
+    napi_is_exception_pending((env), &is_pending);                       \
+    /* If an exception is already pending, don't rethrow it */           \
+    if (!is_pending) {                                                   \
+      const napi_extended_error_info* error_info;                        \
+      napi_get_last_error_info((env), &error_info);                      \
+      const char* error_message = error_info->error_message != NULL ?    \
+        error_info->error_message :                                      \
+        "empty error message";                                           \
+      napi_throw_error((env), error_message);                            \
+    }                                                                    \
+  } while(0);
+
+#define NAPI_ASSERT_BASE(env, assertion, message, ret_val)               \
+  if (!(assertion)) {                                                    \
+    napi_throw_error(                                                    \
+        (env),                                                           \
+        "assertion (" #assertion ") failed: " message);                  \
+    return ret_val;                                                      \
+  }
+
+// Returns NULL on failed assertion.
+// This is meant to be used inside napi_callback methods.
+#define NAPI_ASSERT(env, assertion, message)                             \
+  NAPI_ASSERT_BASE(env, assertion, message, NULL)
+
+// Returns empty on failed assertion.
+// This is meant to be used inside functions with void return type.
+#define NAPI_ASSERT_RETURN_VOID(env, assertion, message)                 \
+  NAPI_ASSERT_BASE(env, assertion, message, NAPI_RETVAL_NOTHING)
+
+#define NAPI_CALL_BASE(env, the_call, ret_val)                           \
+  if ((the_call) != napi_ok) {                                           \
+    GET_AND_THROW_LAST_ERROR((env));                                     \
+    return ret_val;                                                      \
+  }
+
+// Returns NULL if the_call doesn't return napi_ok.
+#define NAPI_CALL(env, the_call)                                         \
+  NAPI_CALL_BASE(env, the_call, NULL)
+
+// Returns empty if the_call doesn't return napi_ok.
+#define NAPI_CALL_RETURN_VOID(env, the_call)                             \
+  NAPI_CALL_BASE(env, the_call, NAPI_RETVAL_NOTHING)
+
+#define DECLARE_NAPI_PROPERTY(name, func)                                \
+  { (name), 0, (func), 0, 0, 0, napi_default, 0 }
diff --git a/test/addons-napi/test_array/test_array.c b/test/addons-napi/test_array/test_array.c
index e5c4be4e8f547d..3634a85e3cac7a 100644
--- a/test/addons-napi/test_array/test_array.c
+++ b/test/addons-napi/test_array/test_array.c
@@ -1,137 +1,93 @@
 #include <node_api.h>
 #include <string.h>
+#include "../common.h"
 
-void Test(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
-
-  if (argc < 2) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
-
+napi_value Test(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
   napi_value args[2];
-  status = napi_get_cb_args(env, info, args, 2);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 2, "Wrong number of arguments");
 
   napi_valuetype valuetype0;
-  status = napi_typeof(env, args[0], &valuetype0);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
-  if (valuetype0 != napi_object) {
-    napi_throw_type_error(
-        env, "Wrong type of argments. Expects an array as first argument.");
-    return;
-  }
+  NAPI_ASSERT(env, valuetype0 == napi_object,
+    "Wrong type of arguments. Expects an array as first argument.");
 
   napi_valuetype valuetype1;
-  status = napi_typeof(env, args[1], &valuetype1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
 
-  if (valuetype1 != napi_number) {
-    napi_throw_type_error(
-        env, "Wrong type of argments. Expects an integer as second argument.");
-    return;
-  }
+  NAPI_ASSERT(env, valuetype1 == napi_number,
+    "Wrong type of arguments. Expects an integer as second argument.");
 
   napi_value array = args[0];
-  int index;
-  status = napi_get_value_int32(env, args[1], &index);
-  if (status != napi_ok) return;
+  int32_t index;
+  NAPI_CALL(env, napi_get_value_int32(env, args[1], &index));
+
+  NAPI_ASSERT(env, index >= 0, "Invalid index. Expects a positive integer.");
 
   bool isarray;
-  status = napi_is_array(env, array, &isarray);
-  if (status != napi_ok) return;
-
-  if (isarray) {
-    uint32_t size;
-    status = napi_get_array_length(env, array, &size);
-    if (status != napi_ok) return;
-
-    if (index >= (int)(size)) {
-      napi_value str;
-      status = napi_create_string_utf8(env, "Index out of bound!", -1, &str);
-      if (status != napi_ok) return;
-
-      status = napi_set_return_value(env, info, str);
-      if (status != napi_ok) return;
-    } else if (index < 0) {
-      napi_throw_type_error(env, "Invalid index. Expects a positive integer.");
-    } else {
-      napi_value ret;
-      status = napi_get_element(env, array, index, &ret);
-      if (status != napi_ok) return;
-
-      status = napi_set_return_value(env, info, ret);
-      if (status != napi_ok) return;
-    }
+  NAPI_CALL(env, napi_is_array(env, array, &isarray));
+
+  if (!isarray) {
+    return NULL;
   }
-}
 
-void New(napi_env env, napi_callback_info info) {
-  napi_status status;
+  uint32_t length;
+  NAPI_CALL(env, napi_get_array_length(env, array, &length));
 
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
+  if ((uint32_t)index >= length) {
+    napi_value str;
+    const char* str_val = "Index out of bound!";
+    size_t str_len = strlen(str_val);
+    NAPI_CALL(env, napi_create_string_utf8(env, str_val, str_len, &str));
 
-  if (argc < 1) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
+    return str;
   }
 
+  napi_value ret;
+  NAPI_CALL(env, napi_get_element(env, array, index, &ret));
+
+  return ret;
+}
+
+napi_value New(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
   napi_value args[1];
-  status = napi_get_cb_args(env, info, args, 1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
-  napi_valuetype valuetype;
-  status = napi_typeof(env, args[0], &valuetype);
-  if (status != napi_ok) return;
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
 
-  if (valuetype != napi_object) {
-    napi_throw_type_error(
-        env, "Wrong type of argments. Expects an array as first argument.");
-    return;
-  }
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
+
+  NAPI_ASSERT(env, valuetype0 == napi_object,
+    "Wrong type of arguments. Expects an array as first argument.");
 
   napi_value ret;
-  status = napi_create_array(env, &ret);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_array(env, &ret));
 
   uint32_t i, length;
-  status = napi_get_array_length(env, args[0], &length);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_array_length(env, args[0], &length));
 
   for (i = 0; i < length; i++) {
     napi_value e;
-    status = napi_get_element(env, args[0], i, &e);
-    if (status != napi_ok) return;
-
-    status = napi_set_element(env, ret, i, e);
-    if (status != napi_ok) return;
+    NAPI_CALL(env, napi_get_element(env, args[0], i, &e));
+    NAPI_CALL(env, napi_set_element(env, ret, i, e));
   }
 
-  status = napi_set_return_value(env, info, ret);
-  if (status != napi_ok) return;
+  return ret;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
-
   napi_property_descriptor descriptors[] = {
-      DECLARE_NAPI_METHOD("Test", Test),
-      DECLARE_NAPI_METHOD("New", New),
+    DECLARE_NAPI_PROPERTY("Test", Test),
+    DECLARE_NAPI_PROPERTY("New", New),
   };
 
-  status = napi_define_properties(
-      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_buffer/test_buffer.c b/test/addons-napi/test_buffer/test_buffer.c
index cfb8f44cc77930..880149e1ff8561 100644
--- a/test/addons-napi/test_buffer/test_buffer.c
+++ b/test/addons-napi/test_buffer/test_buffer.c
@@ -1,43 +1,26 @@
 #include <stdlib.h>
 #include <string.h>
 #include <node_api.h>
-
-#define JS_ASSERT(env, assertion, message)              \
-  if (!(assertion)) {                                   \
-    napi_throw_error(                                   \
-        (env),                                          \
-        "assertion (" #assertion ") failed: " message); \
-    return;                                             \
-  }
-
-#define NAPI_CALL(env, theCall)                                                \
-  if ((theCall) != napi_ok) {                                                  \
-    const napi_extended_error_info* error;                                     \
-    napi_get_last_error_info((env), &error);                                   \
-    const char* errorMessage = error->error_message;                           \
-    errorMessage = errorMessage ? errorMessage : "empty error message";        \
-    napi_throw_error((env), errorMessage);                                     \
-    return;                                                                    \
-  }
+#include "../common.h"
 
 static const char theText[] =
     "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
 
 static int deleterCallCount = 0;
 static void deleteTheText(napi_env env, void* data, void* finalize_hint) {
-  JS_ASSERT(env, data != NULL && strcmp(data, theText) == 0, "invalid data");
+  NAPI_ASSERT_RETURN_VOID(env, data != NULL && strcmp(data, theText) == 0, "invalid data");
   (void)finalize_hint;
   free(data);
   deleterCallCount++;
 }
 
 static void noopDeleter(napi_env env, void* data, void* finalize_hint) {
-  JS_ASSERT(env, data != NULL && strcmp(data, theText) == 0, "invalid data");
+  NAPI_ASSERT_RETURN_VOID(env, data != NULL && strcmp(data, theText) == 0, "invalid data");
   (void)finalize_hint;
   deleterCallCount++;
 }
 
-void newBuffer(napi_env env, napi_callback_info info) {
+napi_value newBuffer(napi_env env, napi_callback_info info) {
   napi_value theBuffer;
   char* theCopy;
   const unsigned int kBufferSize = sizeof(theText);
@@ -48,15 +31,16 @@ void newBuffer(napi_env env, napi_callback_info info) {
                 sizeof(theText),
                 (void**)(&theCopy),
                 &theBuffer));
-  JS_ASSERT(env, theCopy, "Failed to copy static text for newBuffer");
+  NAPI_ASSERT(env, theCopy, "Failed to copy static text for newBuffer");
   memcpy(theCopy, theText, kBufferSize);
-  NAPI_CALL(env, napi_set_return_value(env, info, theBuffer));
+
+  return theBuffer;
 }
 
-void newExternalBuffer(napi_env env, napi_callback_info info) {
+napi_value newExternalBuffer(napi_env env, napi_callback_info info) {
   napi_value theBuffer;
   char* theCopy = strdup(theText);
-  JS_ASSERT(env, theCopy, "Failed to copy static text for newExternalBuffer");
+  NAPI_ASSERT(env, theCopy, "Failed to copy static text for newExternalBuffer");
   NAPI_CALL(env,
             napi_create_external_buffer(
                 env,
@@ -65,48 +49,50 @@ void newExternalBuffer(napi_env env, napi_callback_info info) {
                 deleteTheText,
                 NULL,  // finalize_hint
                 &theBuffer));
-  NAPI_CALL(env, napi_set_return_value(env, info, theBuffer));
+
+  return theBuffer;
 }
 
-void getDeleterCallCount(napi_env env, napi_callback_info info) {
+napi_value getDeleterCallCount(napi_env env, napi_callback_info info) {
   napi_value callCount;
   NAPI_CALL(env, napi_create_number(env, deleterCallCount, &callCount));
-  NAPI_CALL(env, napi_set_return_value(env, info, callCount));
+  return callCount;
 }
 
-void copyBuffer(napi_env env, napi_callback_info info) {
+napi_value copyBuffer(napi_env env, napi_callback_info info) {
   napi_value theBuffer;
   NAPI_CALL(env, napi_create_buffer_copy(
     env, sizeof(theText), theText, NULL, &theBuffer));
-  NAPI_CALL(env, napi_set_return_value(env, info, theBuffer));
+  return theBuffer;
 }
 
-void bufferHasInstance(napi_env env, napi_callback_info info) {
-  size_t argc;
-  NAPI_CALL(env, napi_get_cb_args_length(env, info, &argc));
-  JS_ASSERT(env, argc == 1, "Wrong number of arguments");
-  napi_value theBuffer;
-  NAPI_CALL(env, napi_get_cb_args(env, info, &theBuffer, 1));
+napi_value bufferHasInstance(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+  NAPI_ASSERT(env, argc == 1, "Wrong number of arguments");
+  napi_value theBuffer = args[0];
   bool hasInstance;
   napi_valuetype theType;
   NAPI_CALL(env, napi_typeof(env, theBuffer, &theType));
-  JS_ASSERT(env,
+  NAPI_ASSERT(env,
             theType == napi_object,
             "bufferHasInstance: instance is not an object");
   NAPI_CALL(env, napi_is_buffer(env, theBuffer, &hasInstance));
-  JS_ASSERT(env, hasInstance, "bufferHasInstance: instance is not a buffer");
+  NAPI_ASSERT(env, hasInstance, "bufferHasInstance: instance is not a buffer");
   napi_value returnValue;
   NAPI_CALL(env, napi_get_boolean(env, hasInstance, &returnValue));
-  NAPI_CALL(env, napi_set_return_value(env, info, returnValue));
+  return returnValue;
 }
 
-void bufferInfo(napi_env env, napi_callback_info info) {
-  size_t argc;
-  NAPI_CALL(env, napi_get_cb_args_length(env, info, &argc));
-  JS_ASSERT(env, argc == 1, "Wrong number of arguments");
-  napi_value theBuffer, returnValue;
-  NAPI_CALL(env, napi_get_cb_args(env, info, &theBuffer, 1));
-  char* bufferData;
+napi_value bufferInfo(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+  NAPI_ASSERT(env, argc == 1, "Wrong number of arguments");
+  napi_value theBuffer = args[0];
+  char *bufferData;
+  napi_value returnValue;
   size_t bufferLength;
   NAPI_CALL(env,
             napi_get_buffer_info(
@@ -117,10 +103,10 @@ void bufferInfo(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_get_boolean(env,
     !strcmp(bufferData, theText) && bufferLength == sizeof(theText),
     &returnValue));
-  NAPI_CALL(env, napi_set_return_value(env, info, returnValue));
+  return returnValue;
 }
 
-void staticBuffer(napi_env env, napi_callback_info info) {
+napi_value staticBuffer(napi_env env, napi_callback_info info) {
   napi_value theBuffer;
   NAPI_CALL(
       env,
@@ -130,31 +116,29 @@ void staticBuffer(napi_env env, napi_callback_info info) {
                                   noopDeleter,
                                   NULL,  // finalize_hint
                                   &theBuffer));
-  NAPI_CALL(env, napi_set_return_value(env, info, theBuffer));
+  return theBuffer;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_value theValue;
 
-  NAPI_CALL(env, napi_create_string_utf8(env,
-            theText, sizeof(theText), &theValue));
-  NAPI_CALL(env, napi_set_named_property(env, exports, "theText", theValue));
+  NAPI_CALL_RETURN_VOID(env,
+    napi_create_string_utf8(env, theText, sizeof(theText), &theValue));
+  NAPI_CALL_RETURN_VOID(env,
+    napi_set_named_property(env, exports, "theText", theValue));
 
   napi_property_descriptor methods[] = {
-      DECLARE_NAPI_METHOD("newBuffer", newBuffer),
-      DECLARE_NAPI_METHOD("newExternalBuffer", newExternalBuffer),
-      DECLARE_NAPI_METHOD("getDeleterCallCount", getDeleterCallCount),
-      DECLARE_NAPI_METHOD("copyBuffer", copyBuffer),
-      DECLARE_NAPI_METHOD("bufferHasInstance", bufferHasInstance),
-      DECLARE_NAPI_METHOD("bufferInfo", bufferInfo),
-      DECLARE_NAPI_METHOD("staticBuffer", staticBuffer),
+    DECLARE_NAPI_PROPERTY("newBuffer", newBuffer),
+    DECLARE_NAPI_PROPERTY("newExternalBuffer", newExternalBuffer),
+    DECLARE_NAPI_PROPERTY("getDeleterCallCount", getDeleterCallCount),
+    DECLARE_NAPI_PROPERTY("copyBuffer", copyBuffer),
+    DECLARE_NAPI_PROPERTY("bufferHasInstance", bufferHasInstance),
+    DECLARE_NAPI_PROPERTY("bufferInfo", bufferInfo),
+    DECLARE_NAPI_PROPERTY("staticBuffer", staticBuffer),
   };
-  NAPI_CALL(env,
-            napi_define_properties(
-                env, exports, sizeof(methods) / sizeof(methods[0]), methods));
+
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(methods) / sizeof(methods[0]), methods));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_constructor/test_constructor.c b/test/addons-napi/test_constructor/test_constructor.c
index d0382f2c65ba5e..23463235c315d7 100644
--- a/test/addons-napi/test_constructor/test_constructor.c
+++ b/test/addons-napi/test_constructor/test_constructor.c
@@ -1,107 +1,74 @@
 #include <node_api.h>
+#include "../common.h"
 
 static double value_ = 1;
 napi_ref constructor_;
 
-void GetValue(napi_env env, napi_callback_info info) {
-  napi_status status;
+napi_value GetValue(napi_env env, napi_callback_info info) {
+  size_t argc = 0;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, NULL, NULL, NULL));
 
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
-
-  if (argc != 0) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
+  NAPI_ASSERT(env, argc == 0, "Wrong number of arguments");
 
   napi_value number;
-  status = napi_create_number(env, value_, &number);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_number(env, value_, &number));
 
-  status = napi_set_return_value(env, info, number);
-  if (status != napi_ok) return;
+  return number;
 }
 
-void SetValue(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
+napi_value SetValue(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
-  if (argc != 1) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
+  NAPI_ASSERT(env, argc == 1, "Wrong number of arguments");
 
-  napi_value arg;
-  status = napi_get_cb_args(env, info, &arg, 1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_value_double(env, args[0], &value_));
 
-  status = napi_get_value_double(env, arg, &value_);
-  if (status != napi_ok) return;
+  return NULL;
 }
 
-void Echo(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
+napi_value Echo(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
-  if (argc != 1) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
+  NAPI_ASSERT(env, argc == 1, "Wrong number of arguments");
 
-  napi_value arg;
-  status = napi_get_cb_args(env, info, &arg, 1);
-  if (status != napi_ok) return;
-
-  status = napi_set_return_value(env, info, arg);
-  if (status != napi_ok) return;
+  return args[0];
 }
 
-void New(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  napi_value jsthis;
-  status = napi_get_cb_this(env, info, &jsthis);
-  if (status != napi_ok) return;
+napi_value New(napi_env env, napi_callback_info info) {
+  napi_value _this;
+  NAPI_CALL(env, napi_get_cb_info(env, info, NULL, NULL, NULL, &_this));
 
-  status = napi_set_return_value(env, info, jsthis);
-  if (status != napi_ok) return;
+  return _this;
 }
 
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
-
   napi_value number;
-  status = napi_create_number(env, value_, &number);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_create_number(env, value_, &number));
 
   napi_property_descriptor properties[] = {
-      { "echo", Echo, 0, 0, 0, napi_enumerable, 0 },
-      { "readwriteValue", 0, 0, 0, number, napi_enumerable | napi_writable, 0 },
-      { "readonlyValue", 0, 0, 0, number, napi_enumerable, 0},
-      { "hiddenValue", 0, 0, 0, number, napi_default, 0},
-      { "readwriteAccessor1", 0, GetValue, SetValue, 0, napi_default, 0},
-      { "readwriteAccessor2", 0, GetValue, SetValue, 0, napi_writable, 0},
-      { "readonlyAccessor1", 0, GetValue, NULL, 0, napi_default, 0},
-      { "readonlyAccessor2", 0, GetValue, NULL, 0, napi_writable, 0},
+    { "echo", 0, Echo, 0, 0, 0, napi_enumerable, 0 },
+    { "readwriteValue", 0, 0, 0, 0, number, napi_enumerable | napi_writable, 0 },
+    { "readonlyValue", 0, 0, 0, 0, number, napi_enumerable, 0},
+    { "hiddenValue", 0, 0, 0, 0, number, napi_default, 0},
+    { "readwriteAccessor1", 0, 0, GetValue, SetValue, 0, napi_default, 0},
+    { "readwriteAccessor2", 0, 0, GetValue, SetValue, 0, napi_writable, 0},
+    { "readonlyAccessor1", 0, 0, GetValue, NULL, 0, napi_default, 0},
+    { "readonlyAccessor2", 0, 0, GetValue, NULL, 0, napi_writable, 0},
   };
 
   napi_value cons;
-  status = napi_define_class(env, "MyObject", New,
-    NULL, sizeof(properties)/sizeof(*properties), properties, &cons);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_define_class(env, "MyObject", New,
+    NULL, sizeof(properties)/sizeof(*properties), properties, &cons));
 
-  status = napi_set_named_property(env, module, "exports", cons);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env,
+    napi_set_named_property(env, module, "exports", cons));
 
-  status = napi_create_reference(env, cons, 1, &constructor_);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env,
+    napi_create_reference(env, cons, 1, &constructor_));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_conversions/test_conversions.c b/test/addons-napi/test_conversions/test_conversions.c
index 5fc8b0f2638c5a..637cff43b82c4d 100644
--- a/test/addons-napi/test_conversions/test_conversions.c
+++ b/test/addons-napi/test_conversions/test_conversions.c
@@ -1,237 +1,151 @@
 #include <node_api.h>
+#include "../common.h"
 
-void ThrowLastError(napi_env env) {
-  const napi_extended_error_info* error_info;
-  napi_get_last_error_info(env, &error_info);
-  if (error_info->error_code != napi_ok) {
-    napi_throw_error(env, error_info->error_message);
-  }
-}
-
-void AsBool(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  napi_value input;
-  status = napi_get_cb_args(env, info, &input, 1);
-  if (status != napi_ok) goto done;
+napi_value AsBool(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   bool value;
-  status = napi_get_value_bool(env, input, &value);
-  if (status != napi_ok) goto done;
+  NAPI_CALL(env, napi_get_value_bool(env, args[0], &value));
 
   napi_value output;
-  status = napi_get_boolean(env, value, &output);
-  if (status != napi_ok) goto done;
+  NAPI_CALL(env, napi_get_boolean(env, value, &output));
 
-  status = napi_set_return_value(env, info, output);
-  if (status != napi_ok) goto done;
-
-done:
-  if (status != napi_ok) ThrowLastError(env);
+  return output;
 }
 
-void AsInt32(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  napi_value input;
-  status = napi_get_cb_args(env, info, &input, 1);
-  if (status != napi_ok) goto done;
+napi_value AsInt32(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   int32_t value;
-  status = napi_get_value_int32(env, input, &value);
-  if (status != napi_ok) goto done;
+  NAPI_CALL(env, napi_get_value_int32(env, args[0], &value));
 
   napi_value output;
-  status = napi_create_number(env, value, &output);
-  if (status != napi_ok) goto done;
-
-  status = napi_set_return_value(env, info, output);
-  if (status != napi_ok) goto done;
+  NAPI_CALL(env, napi_create_number(env, value, &output));
 
-done:
-  if (status != napi_ok) ThrowLastError(env);
+  return output;
 }
 
-void AsUInt32(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  napi_value input;
-  status = napi_get_cb_args(env, info, &input, 1);
-  if (status != napi_ok) goto done;
+napi_value AsUInt32(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   uint32_t value;
-  status = napi_get_value_uint32(env, input, &value);
-  if (status != napi_ok) goto done;
+  NAPI_CALL(env, napi_get_value_uint32(env, args[0], &value));
 
   napi_value output;
-  status = napi_create_number(env, value, &output);
-  if (status != napi_ok) goto done;
-
-  status = napi_set_return_value(env, info, output);
-  if (status != napi_ok) goto done;
+  NAPI_CALL(env, napi_create_number(env, value, &output));
 
-done:
-  if (status != napi_ok) ThrowLastError(env);
+  return output;
 }
 
-void AsInt64(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  napi_value input;
-  status = napi_get_cb_args(env, info, &input, 1);
-  if (status != napi_ok) goto done;
+napi_value AsInt64(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   int64_t value;
-  status = napi_get_value_int64(env, input, &value);
-  if (status != napi_ok) goto done;
+  NAPI_CALL(env, napi_get_value_int64(env, args[0], &value));
 
   napi_value output;
-  status = napi_create_number(env, (double)value, &output);
-  if (status != napi_ok) goto done;
+  NAPI_CALL(env, napi_create_number(env, (double)value, &output));
 
-  status = napi_set_return_value(env, info, output);
-  if (status != napi_ok) goto done;
-
-done:
-  if (status != napi_ok) ThrowLastError(env);
+  return output;
 }
 
-void AsDouble(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  napi_value input;
-  status = napi_get_cb_args(env, info, &input, 1);
-  if (status != napi_ok) goto done;
+napi_value AsDouble(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   double value;
-  status = napi_get_value_double(env, input, &value);
-  if (status != napi_ok) goto done;
+  NAPI_CALL(env, napi_get_value_double(env, args[0], &value));
 
   napi_value output;
-  status = napi_create_number(env, value, &output);
-  if (status != napi_ok) goto done;
-
-  status = napi_set_return_value(env, info, output);
-  if (status != napi_ok) goto done;
+  NAPI_CALL(env, napi_create_number(env, value, &output));
 
-done:
-  if (status != napi_ok) ThrowLastError(env);
+  return output;
 }
 
-void AsString(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  napi_value input;
-  status = napi_get_cb_args(env, info, &input, 1);
-  if (status != napi_ok) goto done;
+napi_value AsString(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   char value[100];
-  status = napi_get_value_string_utf8(env, input, value, sizeof(value), NULL);
-  if (status != napi_ok) goto done;
+  NAPI_CALL(env,
+    napi_get_value_string_utf8(env, args[0], value, sizeof(value), NULL));
 
   napi_value output;
-  status = napi_create_string_utf8(env, value, -1, &output);
-  if (status != napi_ok) goto done;
-
-  status = napi_set_return_value(env, info, output);
-  if (status != napi_ok) goto done;
+  NAPI_CALL(env, napi_create_string_utf8(env, value, -1, &output));
 
-done:
-  if (status != napi_ok) ThrowLastError(env);
+  return output;
 }
 
-void ToBool(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  napi_value input;
-  status = napi_get_cb_args(env, info, &input, 1);
-  if (status != napi_ok) goto done;
+napi_value ToBool(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   napi_value output;
-  status = napi_coerce_to_bool(env, input, &output);
-  if (status != napi_ok) goto done;
+  NAPI_CALL(env, napi_coerce_to_bool(env, args[0], &output));
 
-  status = napi_set_return_value(env, info, output);
-  if (status != napi_ok) goto done;
-
-done:
-  if (status != napi_ok) ThrowLastError(env);
+  return output;
 }
 
-void ToNumber(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  napi_value input;
-  status = napi_get_cb_args(env, info, &input, 1);
-  if (status != napi_ok) goto done;
+napi_value ToNumber(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   napi_value output;
-  status = napi_coerce_to_number(env, input, &output);
-  if (status != napi_ok) goto done;
-
-  status = napi_set_return_value(env, info, output);
-  if (status != napi_ok) goto done;
+  NAPI_CALL(env, napi_coerce_to_number(env, args[0], &output));
 
-done:
-  if (status != napi_ok) ThrowLastError(env);
+  return output;
 }
 
-void ToObject(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  napi_value input;
-  status = napi_get_cb_args(env, info, &input, 1);
-  if (status != napi_ok) goto done;
+napi_value ToObject(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   napi_value output;
-  status = napi_coerce_to_object(env, input, &output);
-  if (status != napi_ok) goto done;
-
-  status = napi_set_return_value(env, info, output);
-  if (status != napi_ok) goto done;
+  NAPI_CALL(env, napi_coerce_to_object(env, args[0], &output));
 
-done:
-  if (status != napi_ok) ThrowLastError(env);
+  return output;
 }
 
-void ToString(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  napi_value input;
-  status = napi_get_cb_args(env, info, &input, 1);
-  if (status != napi_ok) goto done;
+napi_value ToString(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   napi_value output;
-  status = napi_coerce_to_string(env, input, &output);
-  if (status != napi_ok) goto done;
+  NAPI_CALL(env, napi_coerce_to_string(env, args[0], &output));
 
-  status = napi_set_return_value(env, info, output);
-  if (status != napi_ok) goto done;
-
-done:
-  if (status != napi_ok) ThrowLastError(env);
+  return output;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)     \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor descriptors[] = {
-      DECLARE_NAPI_METHOD("asBool", AsBool),
-      DECLARE_NAPI_METHOD("asInt32", AsInt32),
-      DECLARE_NAPI_METHOD("asUInt32", AsUInt32),
-      DECLARE_NAPI_METHOD("asInt64", AsInt64),
-      DECLARE_NAPI_METHOD("asDouble", AsDouble),
-      DECLARE_NAPI_METHOD("asString", AsString),
-      DECLARE_NAPI_METHOD("toBool", ToBool),
-      DECLARE_NAPI_METHOD("toNumber", ToNumber),
-      DECLARE_NAPI_METHOD("toObject", ToObject),
-      DECLARE_NAPI_METHOD("toString", ToString),
+    DECLARE_NAPI_PROPERTY("asBool", AsBool),
+    DECLARE_NAPI_PROPERTY("asInt32", AsInt32),
+    DECLARE_NAPI_PROPERTY("asUInt32", AsUInt32),
+    DECLARE_NAPI_PROPERTY("asInt64", AsInt64),
+    DECLARE_NAPI_PROPERTY("asDouble", AsDouble),
+    DECLARE_NAPI_PROPERTY("asString", AsString),
+    DECLARE_NAPI_PROPERTY("toBool", ToBool),
+    DECLARE_NAPI_PROPERTY("toNumber", ToNumber),
+    DECLARE_NAPI_PROPERTY("toObject", ToObject),
+    DECLARE_NAPI_PROPERTY("toString", ToString),
   };
 
-  napi_status status = napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_error/test_error.cc b/test/addons-napi/test_error/test_error.cc
index 1395cb5c4e1976..eb616cac371b0c 100644
--- a/test/addons-napi/test_error/test_error.cc
+++ b/test/addons-napi/test_error/test_error.cc
@@ -1,37 +1,27 @@
 #include <node_api.h>
+#include "../common.h"
 
-void checkError(napi_env e, napi_callback_info info) {
-  napi_status status;
-  napi_value jsError;
-
-  status = napi_get_cb_args(e, info, &jsError, 1);
-  if (status != napi_ok) return;
+napi_value checkError(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
 
   bool r;
-  status = napi_is_error(e, jsError, &r);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_is_error(env, args[0], &r));
 
   napi_value result;
-  status = napi_get_boolean(e, r, &result);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_boolean(env, r, &result));
 
-  status = napi_set_return_value(e, info, result);
-  if (status != napi_ok) return;
+  return result;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
-
   napi_property_descriptor descriptors[] = {
-      DECLARE_NAPI_METHOD("checkError", checkError),
+    DECLARE_NAPI_PROPERTY("checkError", checkError),
   };
 
-  status = napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_exception/test_exception.c b/test/addons-napi/test_exception/test_exception.c
index f92bae323d85e2..191ac3f8ba5aec 100644
--- a/test/addons-napi/test_exception/test_exception.c
+++ b/test/addons-napi/test_exception/test_exception.c
@@ -1,75 +1,59 @@
 #include <node_api.h>
+#include "../common.h"
 
 static bool exceptionWasPending = false;
 
-void returnException(napi_env env, napi_callback_info info) {
-  napi_status status;
-  napi_value jsFunction;
-
-  status = napi_get_cb_args(env, info, &jsFunction, 1);
-  if (status != napi_ok) return;
+napi_value returnException(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   napi_value global;
-  status = napi_get_global(env, &global);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_global(env, &global));
 
   napi_value result;
-  status = napi_call_function(env, global, jsFunction, 0, 0, &result);
-  if (status ==  napi_pending_exception) {
+  napi_status status = napi_call_function(env, global, args[0], 0, 0, &result);
+  if (status == napi_pending_exception) {
     napi_value ex;
-    status = napi_get_and_clear_last_exception(env, &ex);
-    if (status != napi_ok) return;
-
-    status = napi_set_return_value(env, info, ex);
-    if (status != napi_ok) return;
+    NAPI_CALL(env, napi_get_and_clear_last_exception(env, &ex));
+    return ex;
   }
-}
 
-void allowException(napi_env env, napi_callback_info info) {
-  napi_status status;
-  napi_value jsFunction;
+  return NULL;
+}
 
-  status = napi_get_cb_args(env, info, &jsFunction, 1);
-  if (status != napi_ok) return;
+napi_value allowException(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   napi_value global;
-  status = napi_get_global(env, &global);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_global(env, &global));
 
   napi_value result;
-  status = napi_call_function(env, global, jsFunction, 0, 0, &result);
+  napi_call_function(env, global, args[0], 0, 0, &result);
   // Ignore status and check napi_is_exception_pending() instead.
 
-  status = napi_is_exception_pending(env, &exceptionWasPending);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_is_exception_pending(env, &exceptionWasPending));
+  return NULL;
 }
 
-void wasPending(napi_env env, napi_callback_info info) {
-  napi_status status;
-
+napi_value wasPending(napi_env env, napi_callback_info info) {
   napi_value result;
-  status = napi_get_boolean(env, exceptionWasPending, &result);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_boolean(env, exceptionWasPending, &result));
 
-  status = napi_set_return_value(env, info, result);
-  if (status != napi_ok) return;
+  return result;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
-
   napi_property_descriptor descriptors[] = {
-      DECLARE_NAPI_METHOD("returnException", returnException),
-      DECLARE_NAPI_METHOD("allowException", allowException),
-      DECLARE_NAPI_METHOD("wasPending", wasPending),
+    DECLARE_NAPI_PROPERTY("returnException", returnException),
+    DECLARE_NAPI_PROPERTY("allowException", allowException),
+    DECLARE_NAPI_PROPERTY("wasPending", wasPending),
   };
 
-  status = napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_function/test_function.c b/test/addons-napi/test_function/test_function.c
index 1bd421e7bce617..928f99c184cb57 100644
--- a/test/addons-napi/test_function/test_function.c
+++ b/test/addons-napi/test_function/test_function.c
@@ -1,55 +1,35 @@
 #include <node_api.h>
+#include "../common.h"
 
-void Test(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
-
-  if (argc < 1) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
-
+napi_value Test(napi_env env, napi_callback_info info) {
+  size_t argc = 10;
   napi_value args[10];
-  status = napi_get_cb_args(env, info, args, 10);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
-  napi_valuetype valuetype;
-  status = napi_typeof(env, args[0], &valuetype);
-  if (status != napi_ok) return;
+  NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
 
-  if (valuetype != napi_function) {
-    napi_throw_type_error(env, "Wrong type of argments. Expects a function.");
-    return;
-  }
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
+
+  NAPI_ASSERT(env, valuetype0 == napi_function,
+    "Wrong type of arguments. Expects a number as first argument.");
 
-  napi_value function = args[0];
   napi_value* argv = args + 1;
   argc = argc - 1;
 
   napi_value global;
-  status = napi_get_global(env, &global);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_global(env, &global));
 
   napi_value result;
-  status = napi_call_function(env, global, function, argc, argv, &result);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_call_function(env, global, args[0], argc, argv, &result));
 
-  status = napi_set_return_value(env, info, result);
-  if (status != napi_ok) return;
+  return result;
 }
 
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
-
   napi_value fn;
-  status =  napi_create_function(env, NULL, Test, NULL, &fn);
-  if (status != napi_ok) return;
-
-  status = napi_set_named_property(env, exports, "Test", fn);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_create_function(env, NULL, Test, NULL, &fn));
+  NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, exports, "Test", fn));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_instanceof/test_instanceof.c b/test/addons-napi/test_instanceof/test_instanceof.c
index 76df14eb393ab3..76a6542830959d 100644
--- a/test/addons-napi/test_instanceof/test_instanceof.c
+++ b/test/addons-napi/test_instanceof/test_instanceof.c
@@ -1,39 +1,28 @@
 #include <node_api.h>
 #include <stdio.h>
+#include "../common.h"
 
-void doInstanceOf(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  napi_value arguments[2];
-
-  status = napi_get_cb_args(env, info, arguments, 2);
-  if (status != napi_ok) return;
+napi_value doInstanceOf(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value args[2];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   bool instanceof;
-  status = napi_instanceof(env, arguments[0], arguments[1], &instanceof);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_instanceof(env, args[0], args[1], &instanceof));
 
   napi_value result;
-  status = napi_get_boolean(env, instanceof, &result);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_boolean(env, instanceof, &result));
 
-  status = napi_set_return_value(env, info, result);
-  if (status != napi_ok) return;
+  return result;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
-
   napi_property_descriptor descriptors[] = {
-      DECLARE_NAPI_METHOD("doInstanceOf", doInstanceOf),
+    DECLARE_NAPI_PROPERTY("doInstanceOf", doInstanceOf),
   };
 
-  status = napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_napi_status/test_napi_status.cc b/test/addons-napi/test_napi_status/test_napi_status.cc
index b22e1db7638755..9046feffd4a15d 100644
--- a/test/addons-napi/test_napi_status/test_napi_status.cc
+++ b/test/addons-napi/test_napi_status/test_napi_status.cc
@@ -1,47 +1,37 @@
 #include <node_api.h>
+#include "../common.h"
 
-#define DECLARE_NAPI_METHOD(func) \
-  { #func, func, 0, 0, 0, napi_default, 0 }
-
-void createNapiError(napi_env env, napi_callback_info info) {
-  napi_status status;
+napi_value createNapiError(napi_env env, napi_callback_info info) {
   napi_value value;
+  NAPI_CALL(env, napi_create_string_utf8(env, "xyz", 3, &value));
+
   double double_value;
+  napi_status status = napi_get_value_double(env, value, &double_value);
 
-  status = napi_create_string_utf8(env, "xyz", 3, &value);
-  if (status != napi_ok) return;
+  NAPI_ASSERT(env, status != napi_ok, "Failed to produce error condition");
 
-  status = napi_get_value_double(env, value, &double_value);
-  if (status == napi_ok) {
-    napi_throw_error(env, "Failed to produce error condition");
-  }
+  return nullptr;
 }
 
-void testNapiErrorCleanup(napi_env env, napi_callback_info info) {
-  napi_status status;
+napi_value testNapiErrorCleanup(napi_env env, napi_callback_info info) {
   const napi_extended_error_info *error_info = 0;
-  napi_value result;
+  NAPI_CALL(env, napi_get_last_error_info(env, &error_info));
 
-  status = napi_get_last_error_info(env, &error_info);
-  if (status != napi_ok) return;
-
-  status = napi_get_boolean(env, (error_info->error_code == napi_ok), &result);
-  if (status != napi_ok) return;
+  napi_value result;
+  bool is_ok = error_info->error_code == napi_ok;
+  NAPI_CALL(env, napi_get_boolean(env, is_ok, &result));
 
-  napi_set_return_value(env, info, result);
+  return result;
 }
 
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
-
   napi_property_descriptor descriptors[] = {
-      DECLARE_NAPI_METHOD(createNapiError),
-      DECLARE_NAPI_METHOD(testNapiErrorCleanup)
+    DECLARE_NAPI_PROPERTY("createNapiError", createNapiError),
+    DECLARE_NAPI_PROPERTY("testNapiErrorCleanup", testNapiErrorCleanup),
   };
 
-  status = napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_number/test_number.c b/test/addons-napi/test_number/test_number.c
index f38c09d6817ead..4725ddb6a27e85 100644
--- a/test/addons-napi/test_number/test_number.c
+++ b/test/addons-napi/test_number/test_number.c
@@ -1,55 +1,35 @@
 #include <node_api.h>
+#include "../common.h"
 
-void Test(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
-
-  if (argc < 1) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
-
+napi_value Test(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
   napi_value args[1];
-  status = napi_get_cb_args(env, info, args, 1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
-  napi_valuetype valuetype;
-  status = napi_typeof(env, args[0], &valuetype);
-  if (status != napi_ok) return;
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
 
-  if (valuetype != napi_number) {
-    napi_throw_type_error(env, "Wrong type of argments. Expects a number.");
-    return;
-  }
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
+
+  NAPI_ASSERT(env, valuetype0 == napi_number,
+    "Wrong type of arguments. Expects a number as first argument.");
 
   double input;
-  status = napi_get_value_double(env, args[0], &input);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_value_double(env, args[0], &input));
 
   napi_value output;
-  status = napi_create_number(env, input, &output);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_number(env, input, &output));
 
-  status = napi_set_return_value(env, info, output);
-  if (status != napi_ok) return;
+  return output;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
-
   napi_property_descriptor descriptors[] = {
-      DECLARE_NAPI_METHOD("Test", Test),
+    DECLARE_NAPI_PROPERTY("Test", Test),
   };
 
-  status = napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_object/test_object.c b/test/addons-napi/test_object/test_object.c
index 6080201877cc6b..9e02c1d0bb7197 100644
--- a/test/addons-napi/test_object/test_object.c
+++ b/test/addons-napi/test_object/test_object.c
@@ -1,246 +1,154 @@
 #include <node_api.h>
+#include "../common.h"
+#include <string.h>
 
-void Get(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
-
-  if (argc < 2) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
-
+napi_value Get(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
   napi_value args[2];
-  status = napi_get_cb_args(env, info, args, 2);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 2, "Wrong number of arguments");
 
   napi_valuetype valuetype0;
-  status = napi_typeof(env, args[0], &valuetype0);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
-  if (valuetype0 != napi_object) {
-    napi_throw_type_error(
-        env, "Wrong type of argments. Expects an object as first argument.");
-    return;
-  }
+  NAPI_ASSERT(env, valuetype0 == napi_object,
+    "Wrong type of arguments. Expects an object as first argument.");
 
   napi_valuetype valuetype1;
-  status = napi_typeof(env, args[1], &valuetype1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
 
-  if (valuetype1 != napi_string && valuetype1 != napi_symbol) {
-    napi_throw_type_error(env,
-        "Wrong type of argments. Expects a string or symbol as second.");
-    return;
-  }
+  NAPI_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
+    "Wrong type of arguments. Expects a string or symbol as second.");
 
   napi_value object = args[0];
   napi_value output;
-  status = napi_get_property(env, object, args[1], &output);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_property(env, object, args[1], &output));
 
-  status = napi_set_return_value(env, info, output);
-  if (status != napi_ok) return;
+  return output;
 }
 
-void Set(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
-
-  if (argc < 3) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
-
+napi_value Set(napi_env env, napi_callback_info info) {
+  size_t argc = 3;
   napi_value args[3];
-  status = napi_get_cb_args(env, info, args, 3);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 3, "Wrong number of arguments");
 
   napi_valuetype valuetype0;
-  status = napi_typeof(env, args[0], &valuetype0);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
-  if (valuetype0 != napi_object) {
-    napi_throw_type_error(env,
-        "Wrong type of argments. Expects an object as first argument.");
-    return;
-  }
+  NAPI_ASSERT(env, valuetype0 == napi_object,
+    "Wrong type of arguments. Expects an object as first argument.");
 
   napi_valuetype valuetype1;
-  status = napi_typeof(env, args[1], &valuetype1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
 
-  if (valuetype1 != napi_string && valuetype1 != napi_symbol) {
-    napi_throw_type_error(env,
-        "Wrong type of argments. Expects a string or symbol as second.");
-    return;
-  }
+  NAPI_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
+    "Wrong type of arguments. Expects a string or symbol as second.");
 
-  napi_value object = args[0];
-  status = napi_set_property(env, object, args[1], args[2]);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_set_property(env, args[0], args[1], args[2]));
 
   napi_value valuetrue;
-  status = napi_get_boolean(env, true, &valuetrue);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_boolean(env, true, &valuetrue))
 
-  status = napi_set_return_value(env, info, valuetrue);
-  if (status != napi_ok) return;
+  return valuetrue;
 }
 
-void Has(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
-
-  if (argc < 2) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
-
+napi_value Has(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
   napi_value args[2];
-  status = napi_get_cb_args(env, info, args, 2);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 2, "Wrong number of arguments");
 
   napi_valuetype valuetype0;
-  status = napi_typeof(env, args[0], &valuetype0);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
-  if (valuetype0 != napi_object) {
-    napi_throw_type_error(
-        env, "Wrong type of argments. Expects an object as first argument.");
-    return;
-  }
+  NAPI_ASSERT(env, valuetype0 == napi_object,
+    "Wrong type of arguments. Expects an object as first argument.");
 
   napi_valuetype valuetype1;
-  status = napi_typeof(env, args[1], &valuetype1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
 
-  if (valuetype1 != napi_string && valuetype1 != napi_symbol) {
-    napi_throw_type_error(env,
-        "Wrong type of argments. Expects a string or symbol as second.");
-    return;
-  }
+  NAPI_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
+    "Wrong type of arguments. Expects a string or symbol as second.");
 
-  napi_value obj = args[0];
   bool has_property;
-  status = napi_has_property(env, obj, args[1], &has_property);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_has_property(env, args[0], args[1], &has_property));
 
   napi_value ret;
-  status = napi_get_boolean(env, has_property, &ret);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_boolean(env, has_property, &ret));
 
-  status = napi_set_return_value(env, info, ret);
-  if (status != napi_ok) return;
+  return ret;
 }
 
-void New(napi_env env, napi_callback_info info) {
-  napi_status status;
-
+napi_value New(napi_env env, napi_callback_info info) {
   napi_value ret;
-  status = napi_create_object(env, &ret);
+  NAPI_CALL(env, napi_create_object(env, &ret));
 
   napi_value num;
-  status = napi_create_number(env, 987654321, &num);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_number(env, 987654321, &num));
 
-  status = napi_set_named_property(env, ret, "test_number", num);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_set_named_property(env, ret, "test_number", num));
 
   napi_value str;
-  status = napi_create_string_utf8(env, "test string", -1, &str);
-  if (status != napi_ok) return;
+  const char* str_val = "test string";
+  size_t str_len = strlen(str_val);
+  NAPI_CALL(env, napi_create_string_utf8(env, str_val, str_len, &str));
 
-  status = napi_set_named_property(env, ret, "test_string", str);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_set_named_property(env, ret, "test_string", str));
 
-  status = napi_set_return_value(env, info, ret);
-  if (status != napi_ok) return;
+  return ret;
 }
 
-void Inflate(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
-
-  if (argc < 1) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
-
+napi_value Inflate(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
   napi_value args[1];
-  status = napi_get_cb_args(env, info, args, 1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
-  napi_valuetype valuetype;
-  status = napi_typeof(env, args[0], &valuetype);
-  if (status != napi_ok) return;
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
 
-  if (valuetype != napi_object) {
-    napi_throw_type_error(
-        env, "Wrong type of argments. Expects an object as first argument.");
-    return;
-  }
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
-  napi_value obj = args[0];
+  NAPI_ASSERT(env, valuetype0 == napi_object,
+    "Wrong type of arguments. Expects an object as first argument.");
 
+  napi_value obj = args[0];
   napi_value propertynames;
-  status = napi_get_property_names(env, obj, &propertynames);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_property_names(env, obj, &propertynames));
 
   uint32_t i, length;
-  status = napi_get_array_length(env, propertynames, &length);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_array_length(env, propertynames, &length));
 
   for (i = 0; i < length; i++) {
     napi_value property_str;
-    status = napi_get_element(env, propertynames, i, &property_str);
-    if (status != napi_ok) return;
+    NAPI_CALL(env, napi_get_element(env, propertynames, i, &property_str));
 
     napi_value value;
-    status = napi_get_property(env, obj, property_str, &value);
-    if (status != napi_ok) return;
+    NAPI_CALL(env, napi_get_property(env, obj, property_str, &value));
 
     double double_val;
-    status = napi_get_value_double(env, value, &double_val);
-    if (status != napi_ok) return;
-
-    status = napi_create_number(env, double_val + 1, &value);
-    if (status != napi_ok) return;
-
-    status = napi_set_property(env, obj, property_str, value);
-    if (status != napi_ok) return;
+    NAPI_CALL(env, napi_get_value_double(env, value, &double_val));
+    NAPI_CALL(env, napi_create_number(env, double_val + 1, &value));
+    NAPI_CALL(env, napi_set_property(env, obj, property_str, value));
   }
-  status = napi_set_return_value(env, info, obj);
-}
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
+  return obj;
+}
 
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
-
   napi_property_descriptor descriptors[] = {
-      DECLARE_NAPI_METHOD("Get", Get),
-      DECLARE_NAPI_METHOD("Set", Set),
-      DECLARE_NAPI_METHOD("Has", Has),
-      DECLARE_NAPI_METHOD("New", New),
-      DECLARE_NAPI_METHOD("Inflate", Inflate),
+    DECLARE_NAPI_PROPERTY("Get", Get),
+    DECLARE_NAPI_PROPERTY("Set", Set),
+    DECLARE_NAPI_PROPERTY("Has", Has),
+    DECLARE_NAPI_PROPERTY("New", New),
+    DECLARE_NAPI_PROPERTY("Inflate", Inflate),
   };
 
-  status = napi_define_properties(
-      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_properties/test_properties.c b/test/addons-napi/test_properties/test_properties.c
index de6b39ba027577..67e6b1a0d5ed0a 100644
--- a/test/addons-napi/test_properties/test_properties.c
+++ b/test/addons-napi/test_properties/test_properties.c
@@ -1,88 +1,59 @@
 #include <node_api.h>
+#include "../common.h"
 
 static double value_ = 1;
 
-void GetValue(napi_env env, napi_callback_info info) {
-  napi_status status;
+napi_value GetValue(napi_env env, napi_callback_info info) {
+  size_t argc = 0;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, NULL, NULL, NULL));
 
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
-
-  if (argc != 0) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
+  NAPI_ASSERT(env, argc == 0, "Wrong number of arguments");
 
   napi_value number;
-  status = napi_create_number(env, value_, &number);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_number(env, value_, &number));
 
-  status = napi_set_return_value(env, info, number);
-  if (status != napi_ok) return;
+  return number;
 }
 
-void SetValue(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
+napi_value SetValue(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
-  if (argc != 1) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
+  NAPI_ASSERT(env, argc == 1, "Wrong number of arguments");
 
-  napi_value arg;
-  status = napi_get_cb_args(env, info, &arg, 1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_value_double(env, args[0], &value_));
 
-  status = napi_get_value_double(env, arg, &value_);
-  if (status != napi_ok) return;
+  return NULL;
 }
 
-void Echo(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
+napi_value Echo(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
-  if (argc != 1) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
+  NAPI_ASSERT(env, argc == 1, "Wrong number of arguments");
 
-  napi_value arg;
-  status = napi_get_cb_args(env, info, &arg, 1);
-  if (status != napi_ok) return;
-
-  status = napi_set_return_value(env, info, arg);
-  if (status != napi_ok) return;
+  return args[0];
 }
 
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
-
   napi_value number;
-  status = napi_create_number(env, value_, &number);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_create_number(env, value_, &number));
 
   napi_property_descriptor properties[] = {
-      { "echo", Echo, 0, 0, 0, napi_enumerable, 0 },
-      { "readwriteValue", 0, 0, 0, number, napi_enumerable | napi_writable, 0 },
-      { "readonlyValue", 0, 0, 0, number, napi_enumerable, 0},
-      { "hiddenValue", 0, 0, 0, number, napi_default, 0},
-      { "readwriteAccessor1", 0, GetValue, SetValue, 0, napi_default, 0},
-      { "readwriteAccessor2", 0, GetValue, SetValue, 0, napi_writable, 0},
-      { "readonlyAccessor1", 0, GetValue, NULL, 0, napi_default, 0},
-      { "readonlyAccessor2", 0, GetValue, NULL, 0, napi_writable, 0},
+    { "echo", 0, Echo, 0, 0, 0, napi_enumerable, 0 },
+    { "readwriteValue", 0, 0, 0, 0, number, napi_enumerable | napi_writable, 0 },
+    { "readonlyValue", 0, 0, 0, 0, number, napi_enumerable, 0},
+    { "hiddenValue", 0, 0, 0, 0, number, napi_default, 0},
+    { "readwriteAccessor1", 0, 0, GetValue, SetValue, 0, napi_default, 0},
+    { "readwriteAccessor2", 0, 0, GetValue, SetValue, 0, napi_writable, 0},
+    { "readonlyAccessor1", 0, 0, GetValue, NULL, 0, napi_default, 0},
+    { "readonlyAccessor2", 0, 0, GetValue, NULL, 0, napi_writable, 0},
   };
 
-  status = napi_define_properties(
-    env, exports, sizeof(properties) / sizeof(*properties), properties);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(properties) / sizeof(*properties), properties));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_string/test_string.c b/test/addons-napi/test_string/test_string.c
index 1e9c8109d93942..c7c82d7e2e7ac6 100644
--- a/test/addons-napi/test_string/test_string.c
+++ b/test/addons-napi/test_string/test_string.c
@@ -1,134 +1,85 @@
 #include <node_api.h>
+#include "../common.h"
 
-void Copy(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
-
-  if (argc < 1) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
-
+napi_value Copy(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
   napi_value args[1];
-  status = napi_get_cb_args(env, info, args, 1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
 
   napi_valuetype valuetype;
-  status = napi_typeof(env, args[0], &valuetype);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
-  if (valuetype != napi_string) {
-    napi_throw_type_error(env, "Wrong type of argments. Expects a string.");
-    return;
-  }
+  NAPI_ASSERT(env, valuetype == napi_string,
+    "Wrong type of argment. Expects a string.");
 
   char buffer[128];
-  int buffer_size = 128;
+  size_t buffer_size = 128;
+  size_t copied;
 
-  status =
-      napi_get_value_string_utf8(env, args[0], buffer, buffer_size, NULL);
-  if (status != napi_ok) return;
+  NAPI_CALL(env,
+    napi_get_value_string_utf8(env, args[0], buffer, buffer_size, &copied));
 
   napi_value output;
-  status = napi_create_string_utf8(env, buffer, -1, &output);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_string_utf8(env, buffer, copied-1, &output));
 
-  status = napi_set_return_value(env, info, output);
-  if (status != napi_ok) return;
+  return output;
 }
 
-void Length(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
-
-  if (argc < 1) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
-
+napi_value Length(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
   napi_value args[1];
-  status = napi_get_cb_args(env, info, args, 1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
 
   napi_valuetype valuetype;
-  status = napi_typeof(env, args[0], &valuetype);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
-  if (valuetype != napi_string) {
-    napi_throw_type_error(env, "Wrong type of argments. Expects a string.");
-    return;
-  }
+  NAPI_ASSERT(env, valuetype == napi_string,
+    "Wrong type of argment. Expects a string.");
 
   size_t length;
-  status = napi_get_value_string_length(env, args[0], &length);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_value_string_length(env, args[0], &length));
 
   napi_value output;
-  status = napi_create_number(env, (double)length, &output);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_number(env, (double)length, &output));
 
-  status = napi_set_return_value(env, info, output);
-  if (status != napi_ok) return;
+  return output;
 }
 
-void Utf8Length(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
-
-  if (argc < 1) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
-
+napi_value Utf8Length(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
   napi_value args[1];
-  status = napi_get_cb_args(env, info, args, 1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
 
   napi_valuetype valuetype;
-  status = napi_typeof(env, args[0], &valuetype);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
-  if (valuetype != napi_string) {
-    napi_throw_type_error(env, "Wrong type of argments. Expects a string.");
-    return;
-  }
+  NAPI_ASSERT(env, valuetype == napi_string,
+    "Wrong type of argment. Expects a string.");
 
   size_t length;
-  status = napi_get_value_string_utf8(env, args[0], NULL, 0, &length);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_value_string_utf8(env, args[0], NULL, 0, &length));
 
   napi_value output;
-  status = napi_create_number(env, (double)length, &output);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_number(env, (double)length, &output));
 
-  status = napi_set_return_value(env, info, output);
-  if (status != napi_ok) return;
+  return output;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
-
   napi_property_descriptor properties[] = {
-      DECLARE_NAPI_METHOD("Copy", Copy),
-      DECLARE_NAPI_METHOD("Length", Length),
-      DECLARE_NAPI_METHOD("Utf8Length", Utf8Length),
+    DECLARE_NAPI_PROPERTY("Copy", Copy),
+    DECLARE_NAPI_PROPERTY("Length", Length),
+    DECLARE_NAPI_PROPERTY("Utf8Length", Utf8Length),
   };
 
-  status = napi_define_properties(
-      env, exports, sizeof(properties) / sizeof(*properties), properties);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(properties) / sizeof(*properties), properties));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_symbol/test_symbol.c b/test/addons-napi/test_symbol/test_symbol.c
index af694b1dd3543b..f85567c071e256 100644
--- a/test/addons-napi/test_symbol/test_symbol.c
+++ b/test/addons-napi/test_symbol/test_symbol.c
@@ -1,94 +1,60 @@
 #include <node_api.h>
+#include "../common.h"
 
-void Test(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
-
-  if (argc < 1) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
-
+napi_value Test(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
   napi_value args[1];
-  status = napi_get_cb_args(env, info, args, 1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
 
   napi_valuetype valuetype;
-  status = napi_typeof(env, args[0], &valuetype);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
-  if (valuetype != napi_symbol) {
-    napi_throw_type_error(env, "Wrong type of argments. Expects a symbol.");
-    return;
-  }
+  NAPI_ASSERT(env, valuetype == napi_symbol,
+    "Wrong type of argments. Expects a symbol.");
 
   char buffer[128];
-  int buffer_size = 128;
+  size_t buffer_size = 128;
 
-  status =
-      napi_get_value_string_utf8(env, args[0], buffer, buffer_size, NULL);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_value_string_utf8(
+    env, args[0], buffer, buffer_size, NULL));
 
   napi_value output;
-  status = napi_create_string_utf8(env, buffer, -1, &output);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_string_utf8(env, buffer, buffer_size, &output));
 
-  status = napi_set_return_value(env, info, output);
-  if (status != napi_ok) return;
+  return output;
 }
 
-void New(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
+napi_value New(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
+  napi_value description = NULL;
   if (argc >= 1) {
-    napi_value args[1];
-    napi_get_cb_args(env, info, args, 1);
-
     napi_valuetype valuetype;
-    status = napi_typeof(env, args[0], &valuetype);
-    if (status != napi_ok) return;
-
-    if (valuetype != napi_string) {
-      napi_throw_type_error(env, "Wrong type of argments. Expects a string.");
-      return;
-    }
-
-    napi_value symbol;
-    status = napi_create_symbol(env, args[0], &symbol);
-    if (status != napi_ok) return;
-
-    status = napi_set_return_value(env, info, symbol);
-    if (status != napi_ok) return;
-  } else {
-    napi_value symbol;
-    status = napi_create_symbol(env, NULL, &symbol);
-    if (status != napi_ok) return;
-
-    status = napi_set_return_value(env, info, symbol);
-    if (status != napi_ok) return;
+    NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
+
+    NAPI_ASSERT(env, valuetype == napi_string,
+      "Wrong type of arguments. Expects a string.");
+
+    description = args[0];
   }
-}
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
+  napi_value symbol;
+  NAPI_CALL(env, napi_create_symbol(env, description, &symbol));
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
+  return symbol;
+}
 
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor properties[] = {
-      DECLARE_NAPI_METHOD("New", New),
+    DECLARE_NAPI_PROPERTY("New", New),
   };
 
-  status = napi_define_properties(
-      env, exports, sizeof(properties) / sizeof(*properties), properties);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(properties) / sizeof(*properties), properties));
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_typedarray/test_typedarray.c b/test/addons-napi/test_typedarray/test_typedarray.c
index 00217a8cc0d18f..d77945486518a2 100644
--- a/test/addons-napi/test_typedarray/test_typedarray.c
+++ b/test/addons-napi/test_typedarray/test_typedarray.c
@@ -1,82 +1,56 @@
 #include <node_api.h>
 #include <string.h>
+#include "../common.h"
 
-void Multiply(napi_env env, napi_callback_info info) {
-  napi_status status;
-
-  size_t argc;
-  status = napi_get_cb_args_length(env, info, &argc);
-  if (status != napi_ok) return;
-
-  if (argc != 2) {
-    napi_throw_type_error(env, "Wrong number of arguments");
-    return;
-  }
-
+napi_value Multiply(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
   napi_value args[2];
-  status = napi_get_cb_args(env, info, args, 2);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc == 2, "Wrong number of arguments");
 
   napi_valuetype valuetype0;
-  status = napi_typeof(env, args[0], &valuetype0);
-  if (status != napi_ok) return;
-
-  if (valuetype0 != napi_object) {
-    napi_throw_type_error(
-        env,
-        "Wrong type of argments. Expects a typed array as first argument.");
-    return;
-  }
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
+
+  NAPI_ASSERT(env, valuetype0 == napi_object,
+    "Wrong type of argments. Expects a typed array as first argument.");
 
   napi_value input_array = args[0];
-  bool istypedarray;
-  status = napi_is_typedarray(env, input_array, &istypedarray);
-  if (status != napi_ok) return;
-
-  if (!istypedarray) {
-    napi_throw_type_error(
-        env,
-        "Wrong type of argments. Expects a typed array as first argument.");
-    return;
-  }
+  bool is_typedarray;
+  NAPI_CALL(env, napi_is_typedarray(env, input_array, &is_typedarray));
+
+  NAPI_ASSERT(env, is_typedarray,
+    "Wrong type of argments. Expects a typed array as first argument.");
 
   napi_valuetype valuetype1;
-  status = napi_typeof(env, args[1], &valuetype1);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
 
-  if (valuetype1 != napi_number) {
-    napi_throw_type_error(
-        env, "Wrong type of argments. Expects a number as second argument.");
-    return;
-  }
+  NAPI_ASSERT(env, valuetype1 == napi_number,
+    "Wrong type of argments. Expects a number as second argument.");
 
   double multiplier;
-  status = napi_get_value_double(env, args[1], &multiplier);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_value_double(env, args[1], &multiplier));
 
   napi_typedarray_type type;
   napi_value input_buffer;
   size_t byte_offset;
   size_t i, length;
-  status = napi_get_typedarray_info(
-      env, input_array, &type, &length, NULL, &input_buffer, &byte_offset);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_typedarray_info(
+    env, input_array, &type, &length, NULL, &input_buffer, &byte_offset));
 
   void* data;
   size_t byte_length;
-  status = napi_get_arraybuffer_info(env, input_buffer, &data, &byte_length);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_get_arraybuffer_info(
+    env, input_buffer, &data, &byte_length));
 
   napi_value output_buffer;
   void* output_ptr = NULL;
-  status =
-      napi_create_arraybuffer(env, byte_length, &output_ptr, &output_buffer);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_arraybuffer(
+    env, byte_length, &output_ptr, &output_buffer));
 
   napi_value output_array;
-  status = napi_create_typedarray(
-      env, type, length, output_buffer, byte_offset, &output_array);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_typedarray(
+      env, type, length, output_buffer, byte_offset, &output_array));
 
   if (type == napi_uint8_array) {
     uint8_t* input_bytes = (uint8_t*)(data) + byte_offset;
@@ -92,53 +66,43 @@ void Multiply(napi_env env, napi_callback_info info) {
     }
   } else {
     napi_throw_error(env, "Typed array was of a type not expected by test.");
-    return;
+    return NULL;
   }
 
-  status = napi_set_return_value(env, info, output_array);
-  if (status != napi_ok) return;
+  return output_array;
 }
 
-void External(napi_env env, napi_callback_info info) {
+napi_value External(napi_env env, napi_callback_info info) {
   static int8_t externalData[] = {0, 1, 2};
 
   napi_value output_buffer;
-  napi_status status = napi_create_external_arraybuffer(
-      env,
-      externalData,
-      sizeof(externalData),
-      NULL,  // finalize_callback
-      NULL,  // finalize_hint
-      &output_buffer);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_external_arraybuffer(
+    env,
+    externalData,
+    sizeof(externalData),
+    NULL,  // finalize_callback
+    NULL,  // finalize_hint
+    &output_buffer));
 
   napi_value output_array;
-  status = napi_create_typedarray(env,
-                                  napi_int8_array,
-                                  sizeof(externalData) / sizeof(uint8_t),
-                                  output_buffer,
-                                  0,
-                                  &output_array);
-  if (status != napi_ok) return;
-
-  status = napi_set_return_value(env, info, output_array);
-  if (status != napi_ok) return;
+  NAPI_CALL(env, napi_create_typedarray(env,
+    napi_int8_array,
+    sizeof(externalData) / sizeof(int8_t),
+    output_buffer,
+    0,
+    &output_array));
+
+  return output_array;
 }
 
-#define DECLARE_NAPI_METHOD(name, func)                          \
-  { name, func, 0, 0, 0, napi_default, 0 }
-
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_status status;
-
   napi_property_descriptor descriptors[] = {
-      DECLARE_NAPI_METHOD("Multiply", Multiply),
-      DECLARE_NAPI_METHOD("External", External),
+    DECLARE_NAPI_PROPERTY("Multiply", Multiply),
+    DECLARE_NAPI_PROPERTY("External", External),
   };
 
-  status = napi_define_properties(
-      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors);
-  if (status != napi_ok) return;
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
 }
 
 NAPI_MODULE(addon, Init)

From 257b28c5a21e8a2d91fb1c9c690193b7a4bf1284 Mon Sep 17 00:00:00 2001
From: "taylor.woll" <tawoll@ntdev.microsoft.com>
Date: Tue, 28 Mar 2017 02:06:58 -0700
Subject: [PATCH 009/183] n-api: implement async helper methods

Based on the async methods we had in abi-stable-node before the napi
feature landed in node/master. Changed this set of APIs to handle
error cases and removed a lot of the extra methods we had for setting
all the pieces of napi_work opting instead to pass all of those as
arguments to napi_create_async_work as none of those parameters are
optional except for the complete callback, anyway.

Renamed the napi_work struct to napi_async_work and replace the
struct itself with a class which can better encapsulate the object
lifetime and uv_work_t that we're trying to wrap anyway.

Added a napi_async_callback type for the async helper callbacks
instead of taking raw function pointers and make this callback take a
napi_env parameter as well as the void* data it was already taking.

Call the complete handler for the async work item with a napi_status
code translated from the uvlib error code.

The execute callback is required for napi_create_async_work, though
complete callback is still optional.

Also added some async unit tests for addons-napi based on the
addons/async_hello_world test.

PR-URL: https://github.com/nodejs/node/pull/12250
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
Reviewed-By: Hitesh Kanwathirtha <hiteshk@microsoft.com>
---
 src/node_api.cc                           | 137 +++++++++++++++++++++-
 src/node_api.h                            |  15 +++
 src/node_api_types.h                      |  47 ++++----
 test/addons-napi/test_async/binding.gyp   |   8 ++
 test/addons-napi/test_async/test.js       |  10 ++
 test/addons-napi/test_async/test_async.cc | 122 +++++++++++++++++++
 6 files changed, 318 insertions(+), 21 deletions(-)
 create mode 100644 test/addons-napi/test_async/binding.gyp
 create mode 100644 test/addons-napi/test_async/test.js
 create mode 100644 test/addons-napi/test_async/test_async.cc

diff --git a/src/node_api.cc b/src/node_api.cc
index 35f737619ef239..52015a2443ca95 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -15,6 +15,7 @@
 #include <cmath>
 #include <vector>
 #include "node_api.h"
+#include "env-inl.h"
 #include "node_api_backport.h"
 
 static
@@ -707,7 +708,8 @@ const char* error_messages[] = {nullptr,
                                 "A boolean was expected",
                                 "An array was expected",
                                 "Unknown failure",
-                                "An exception is pending"};
+                                "An exception is pending",
+                                "The async work item was cancelled"};
 
 void napi_clear_last_error(napi_env env) {
   env->last_error.error_code = napi_ok;
@@ -2576,3 +2578,136 @@ napi_status napi_get_typedarray_info(napi_env env,
 
   return GET_RETURN_STATUS(env);
 }
+
+namespace uvimpl {
+
+napi_status ConvertUVErrorCode(int code) {
+  switch (code) {
+  case 0:
+    return napi_ok;
+  case UV_EINVAL:
+    return napi_invalid_arg;
+  case UV_ECANCELED:
+    return napi_cancelled;
+  }
+
+  return napi_generic_failure;
+}
+
+// Wrapper around uv_work_t which calls user-provided callbacks.
+class Work {
+ private:
+  explicit Work(napi_env env,
+                napi_async_execute_callback execute = nullptr,
+                napi_async_complete_callback complete = nullptr,
+                void* data = nullptr)
+    : _env(env),
+    _data(data),
+    _execute(execute),
+    _complete(complete) {
+    _request.data = this;
+  }
+
+  ~Work() { }
+
+ public:
+  static Work* New(napi_env env,
+                   napi_async_execute_callback execute,
+                   napi_async_complete_callback complete,
+                   void* data) {
+    return new Work(env, execute, complete, data);
+  }
+
+  static void Delete(Work* work) {
+    delete work;
+  }
+
+  static void ExecuteCallback(uv_work_t* req) {
+    Work* work = static_cast<Work*>(req->data);
+    work->_execute(work->_env, work->_data);
+  }
+
+  static void CompleteCallback(uv_work_t* req, int status) {
+    Work* work = static_cast<Work*>(req->data);
+
+    if (work->_complete != nullptr) {
+      work->_complete(work->_env, ConvertUVErrorCode(status), work->_data);
+    }
+  }
+
+  uv_work_t* Request() {
+    return &_request;
+  }
+
+ private:
+  napi_env _env;
+  void* _data;
+  uv_work_t _request;
+  napi_async_execute_callback _execute;
+  napi_async_complete_callback _complete;
+};
+
+}  // end of namespace uvimpl
+
+#define CALL_UV(env, condition)                                         \
+  do {                                                                  \
+    int result = (condition);                                           \
+    napi_status status = uvimpl::ConvertUVErrorCode(result);            \
+    if (status != napi_ok) {                                            \
+      return napi_set_last_error(env, status, result);                  \
+    }                                                                   \
+  } while (0)
+
+napi_status napi_create_async_work(napi_env env,
+                                   napi_async_execute_callback execute,
+                                   napi_async_complete_callback complete,
+                                   void* data,
+                                   napi_async_work* result) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, execute);
+  CHECK_ARG(env, result);
+
+  uvimpl::Work* work = uvimpl::Work::New(env, execute, complete, data);
+
+  *result = reinterpret_cast<napi_async_work>(work);
+
+  return napi_ok;
+}
+
+napi_status napi_delete_async_work(napi_env env, napi_async_work work) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, work);
+
+  uvimpl::Work::Delete(reinterpret_cast<uvimpl::Work*>(work));
+
+  return napi_ok;
+}
+
+napi_status napi_queue_async_work(napi_env env, napi_async_work work) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, work);
+
+  // Consider: Encapsulate the uv_loop_t into an opaque pointer parameter
+  uv_loop_t* event_loop =
+    node::Environment::GetCurrent(env->isolate)->event_loop();
+
+  uvimpl::Work* w = reinterpret_cast<uvimpl::Work*>(work);
+
+  CALL_UV(env, uv_queue_work(event_loop,
+                             w->Request(),
+                             uvimpl::Work::ExecuteCallback,
+                             uvimpl::Work::CompleteCallback));
+
+  return napi_ok;
+}
+
+napi_status napi_cancel_async_work(napi_env env, napi_async_work work) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, work);
+
+  uvimpl::Work* w = reinterpret_cast<uvimpl::Work*>(work);
+
+  CALL_UV(env, uv_cancel(reinterpret_cast<uv_req_t*>(w->Request())));
+
+  return napi_ok;
+}
diff --git a/src/node_api.h b/src/node_api.h
index c232d9aa039d13..8791954a377052 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -457,6 +457,21 @@ NAPI_EXTERN napi_status napi_get_typedarray_info(napi_env env,
                                                  void** data,
                                                  napi_value* arraybuffer,
                                                  size_t* byte_offset);
+
+// Methods to manage simple async operations
+NAPI_EXTERN
+napi_status napi_create_async_work(napi_env env,
+                                   napi_async_execute_callback execute,
+                                   napi_async_complete_callback complete,
+                                   void* data,
+                                   napi_async_work* result);
+NAPI_EXTERN napi_status napi_delete_async_work(napi_env env,
+                                               napi_async_work work);
+NAPI_EXTERN napi_status napi_queue_async_work(napi_env env,
+                                              napi_async_work work);
+NAPI_EXTERN napi_status napi_cancel_async_work(napi_env env,
+                                               napi_async_work work);
+
 EXTERN_C_END
 
 #endif  // SRC_NODE_API_H__
diff --git a/src/node_api_types.h b/src/node_api_types.h
index f439cce1f9003b..4bf1b8263139d8 100644
--- a/src/node_api_types.h
+++ b/src/node_api_types.h
@@ -16,12 +16,7 @@ typedef struct napi_ref__ *napi_ref;
 typedef struct napi_handle_scope__ *napi_handle_scope;
 typedef struct napi_escapable_handle_scope__ *napi_escapable_handle_scope;
 typedef struct napi_callback_info__ *napi_callback_info;
-
-typedef napi_value (*napi_callback)(napi_env env,
-                                    napi_callback_info info);
-typedef void (*napi_finalize)(napi_env env,
-                              void* finalize_data,
-                              void* finalize_hint);
+typedef struct napi_async_work__ *napi_async_work;
 
 typedef enum {
   napi_default = 0,
@@ -34,20 +29,6 @@ typedef enum {
   napi_static = 1 << 10,
 } napi_property_attributes;
 
-typedef struct {
-  // One of utf8name or name should be NULL.
-  const char* utf8name;
-  napi_value name;
-
-  napi_callback method;
-  napi_callback getter;
-  napi_callback setter;
-  napi_value value;
-
-  napi_property_attributes attributes;
-  void* data;
-} napi_property_descriptor;
-
 typedef enum {
   // ES6 types (corresponds to typeof)
   napi_undefined,
@@ -85,9 +66,35 @@ typedef enum {
   napi_array_expected,
   napi_generic_failure,
   napi_pending_exception,
+  napi_cancelled,
   napi_status_last
 } napi_status;
 
+typedef napi_value (*napi_callback)(napi_env env,
+                                    napi_callback_info info);
+typedef void (*napi_finalize)(napi_env env,
+                              void* finalize_data,
+                              void* finalize_hint);
+typedef void (*napi_async_execute_callback)(napi_env env,
+                                            void* data);
+typedef void (*napi_async_complete_callback)(napi_env env,
+                                             napi_status status,
+                                             void* data);
+
+typedef struct {
+  // One of utf8name or name should be NULL.
+  const char* utf8name;
+  napi_value name;
+
+  napi_callback method;
+  napi_callback getter;
+  napi_callback setter;
+  napi_value value;
+
+  napi_property_attributes attributes;
+  void* data;
+} napi_property_descriptor;
+
 typedef struct {
   const char* error_message;
   void* engine_reserved;
diff --git a/test/addons-napi/test_async/binding.gyp b/test/addons-napi/test_async/binding.gyp
new file mode 100644
index 00000000000000..cf8beb70c68e78
--- /dev/null
+++ b/test/addons-napi/test_async/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_async",
+      "sources": [ "test_async.cc" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_async/test.js b/test/addons-napi/test_async/test.js
new file mode 100644
index 00000000000000..0bfd955ac77006
--- /dev/null
+++ b/test/addons-napi/test_async/test.js
@@ -0,0 +1,10 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const test_async = require(`./build/${common.buildType}/test_async`);
+
+test_async(5, common.mustCall(function(err, val) {
+  assert.strictEqual(err, null);
+  assert.strictEqual(val, 10);
+  process.nextTick(common.mustCall(function() {}));
+}));
diff --git a/test/addons-napi/test_async/test_async.cc b/test/addons-napi/test_async/test_async.cc
new file mode 100644
index 00000000000000..bc0af66d26ec61
--- /dev/null
+++ b/test/addons-napi/test_async/test_async.cc
@@ -0,0 +1,122 @@
+#include <node_api.h>
+#include "../common.h"
+
+#if defined _WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+
+typedef struct {
+  int32_t _input;
+  int32_t _output;
+  napi_ref _callback;
+  napi_async_work _request;
+} carrier;
+
+carrier the_carrier;
+
+struct AutoHandleScope {
+  explicit AutoHandleScope(napi_env env)
+  : _env(env),
+  _scope(nullptr) {
+    napi_open_handle_scope(_env, &_scope);
+  }
+  ~AutoHandleScope() {
+    napi_close_handle_scope(_env, _scope);
+  }
+ private:
+  AutoHandleScope() { }
+
+  napi_env _env;
+  napi_handle_scope _scope;
+};
+
+void Execute(napi_env env, void* data) {
+#if defined _WIN32
+  Sleep(1000);
+#else
+  sleep(1);
+#endif
+  carrier* c = static_cast<carrier*>(data);
+
+  if (c != &the_carrier) {
+    napi_throw_type_error(env, "Wrong data parameter to Execute.");
+    return;
+  }
+
+  c->_output = c->_input * 2;
+}
+
+void Complete(napi_env env, napi_status status, void* data) {
+  AutoHandleScope scope(env);
+  carrier* c = static_cast<carrier*>(data);
+
+  if (c != &the_carrier) {
+    napi_throw_type_error(env, "Wrong data parameter to Complete.");
+    return;
+  }
+
+  if (status != napi_ok) {
+    napi_throw_type_error(env, "Execute callback failed.");
+    return;
+  }
+
+  napi_value argv[2];
+
+  NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &argv[0]));
+  NAPI_CALL_RETURN_VOID(env, napi_create_number(env, c->_output, &argv[1]));
+  napi_value callback;
+  NAPI_CALL_RETURN_VOID(env,
+    napi_get_reference_value(env, c->_callback, &callback));
+  napi_value global;
+  NAPI_CALL_RETURN_VOID(env, napi_get_global(env, &global));
+
+  napi_value result;
+  NAPI_CALL_RETURN_VOID(env,
+    napi_call_function(env, global, callback, 2, argv, &result));
+
+  NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, c->_callback));
+  NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, c->_request));
+}
+
+napi_value Test(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value argv[2];
+  napi_value _this;
+  void* data;
+  NAPI_CALL(env,
+    napi_get_cb_info(env, info, &argc, argv, &_this, &data));
+  NAPI_ASSERT(env, argc >= 2, "Not enough arguments, expected 2.");
+
+  napi_valuetype t;
+  NAPI_CALL(env, napi_typeof(env, argv[0], &t));
+  NAPI_ASSERT(env, t == napi_number,
+    "Wrong first argument, integer expected.");
+  NAPI_CALL(env, napi_typeof(env, argv[1], &t));
+  NAPI_ASSERT(env, t == napi_function,
+    "Wrong second argument, function expected.");
+
+  the_carrier._output = 0;
+
+  NAPI_CALL(env,
+    napi_get_value_int32(env, argv[0], &the_carrier._input));
+  NAPI_CALL(env,
+    napi_create_reference(env, argv[1], 1, &the_carrier._callback));
+  NAPI_CALL(env, napi_create_async_work(
+    env, Execute, Complete, &the_carrier, &the_carrier._request));
+  NAPI_CALL(env,
+    napi_queue_async_work(env, the_carrier._request));
+
+  return nullptr;
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_value test;
+  NAPI_CALL_RETURN_VOID(env,
+    napi_create_function(env, "Test", Test, nullptr, &test));
+  NAPI_CALL_RETURN_VOID(env,
+    napi_set_named_property(env, module, "exports", test));
+}
+
+NAPI_MODULE(addon, Init)

From e6055bbfd37a8b5b8bed559ceae2b58bf3f5999e Mon Sep 17 00:00:00 2001
From: Ben Noordhuis <info@bnoordhuis.nl>
Date: Tue, 11 Apr 2017 11:39:51 +0200
Subject: [PATCH 010/183] n-api: fix -Wmismatched-tags compiler warning

`napi_env__` was declared as a struct in one place and a class in
another.

PR-URL: https://github.com/nodejs/node/pull/12333
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 src/node_api.cc | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 52015a2443ca95..b20d177fba2afa 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -24,8 +24,7 @@ napi_status napi_set_last_error(napi_env env, napi_status error_code,
                                 void* engine_reserved = nullptr);
 void napi_clear_last_error(napi_env env);
 
-class napi_env__ {
- public:
+struct napi_env__ {
   explicit napi_env__(v8::Isolate* _isolate): isolate(_isolate),
       has_instance_available(true), last_error() {}
   ~napi_env__() {

From 3e6db1f00980e7b756b0a454d00ff0b007849f66 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Mon, 10 Apr 2017 23:09:15 -0400
Subject: [PATCH 011/183] test: improve test coverage for n-api

Add basic tests for handle scopes as code coverage
reports that we are not covering these with the existing
tests.

PR-URL: https://github.com/nodejs/node/pull/12327
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 .../addons-napi/test_handle_scope/binding.gyp |  8 ++++
 test/addons-napi/test_handle_scope/test.js    | 10 +++++
 .../test_handle_scope/test_handle_scope.c     | 42 +++++++++++++++++++
 3 files changed, 60 insertions(+)
 create mode 100644 test/addons-napi/test_handle_scope/binding.gyp
 create mode 100644 test/addons-napi/test_handle_scope/test.js
 create mode 100644 test/addons-napi/test_handle_scope/test_handle_scope.c

diff --git a/test/addons-napi/test_handle_scope/binding.gyp b/test/addons-napi/test_handle_scope/binding.gyp
new file mode 100644
index 00000000000000..daa96681a52018
--- /dev/null
+++ b/test/addons-napi/test_handle_scope/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_handle_scope",
+      "sources": [ "test_handle_scope.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_handle_scope/test.js b/test/addons-napi/test_handle_scope/test.js
new file mode 100644
index 00000000000000..ed52410f8075dd
--- /dev/null
+++ b/test/addons-napi/test_handle_scope/test.js
@@ -0,0 +1,10 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+
+// testing handle scope api calls
+const testHandleScope =
+    require(`./build/${common.buildType}/test_handle_scope`);
+
+testHandleScope.NewScope();
+assert.ok(testHandleScope.NewScopeEscape() instanceof Object);
diff --git a/test/addons-napi/test_handle_scope/test_handle_scope.c b/test/addons-napi/test_handle_scope/test_handle_scope.c
new file mode 100644
index 00000000000000..f88c04705ebdd2
--- /dev/null
+++ b/test/addons-napi/test_handle_scope/test_handle_scope.c
@@ -0,0 +1,42 @@
+#include <node_api.h>
+#include "../common.h"
+#include <string.h>
+
+// these tests validate the handle scope functions in the normal
+// flow.  Forcing gc behaviour to fully validate they are doing
+// the right right thing would be quite hard so we keep it
+// simple for now.
+
+napi_value NewScope(napi_env env, napi_callback_info info) {
+  napi_handle_scope scope;
+  napi_value output = NULL;
+
+  NAPI_CALL(env, napi_open_handle_scope(env, &scope));
+  NAPI_CALL(env, napi_create_object(env, &output));
+  NAPI_CALL(env, napi_close_handle_scope(env, scope));
+  return NULL;
+}
+
+napi_value NewScopeEscape(napi_env env, napi_callback_info info) {
+  napi_escapable_handle_scope scope;
+  napi_value output = NULL;
+  napi_value escapee = NULL;
+
+  NAPI_CALL(env, napi_open_escapable_handle_scope(env, &scope));
+  NAPI_CALL(env, napi_create_object(env, &output));
+  NAPI_CALL(env, napi_escape_handle(env, scope, output, &escapee));
+  NAPI_CALL(env, napi_close_escapable_handle_scope(env, scope));
+  return escapee;
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_property_descriptor properties[] = {
+    DECLARE_NAPI_PROPERTY("NewScope", NewScope),
+    DECLARE_NAPI_PROPERTY("NewScopeEscape", NewScopeEscape),
+  };
+
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(properties) / sizeof(*properties), properties));
+}
+
+NAPI_MODULE(addon, Init)

From a5d892dccdbcfce7b2dd2ff30855cdb2bd3a83f3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= <targos@protonmail.com>
Date: Fri, 7 Apr 2017 16:15:46 +0200
Subject: [PATCH 012/183] test: add second argument to assert.throws

This adds RegExp or error constructor arguments to the remaining places
where it is missing in preparation for the commit that will enforce the
presence of at least two arguments.

PR-URL: https://github.com/nodejs/node/pull/12270
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 test/addons-napi/test_constructor/test.js |  6 +++---
 test/addons-napi/test_properties/test.js  |  6 +++---
 test/parallel/test-assert.js              | 22 +++++++++++++---------
 3 files changed, 19 insertions(+), 15 deletions(-)

diff --git a/test/addons-napi/test_constructor/test.js b/test/addons-napi/test_constructor/test.js
index b1762c2253b99a..92440bf49e74c1 100644
--- a/test/addons-napi/test_constructor/test.js
+++ b/test/addons-napi/test_constructor/test.js
@@ -13,7 +13,7 @@ assert.strictEqual(test_object.readwriteValue, 1);
 test_object.readwriteValue = 2;
 assert.strictEqual(test_object.readwriteValue, 2);
 
-assert.throws(() => { test_object.readonlyValue = 3; });
+assert.throws(() => { test_object.readonlyValue = 3; }, TypeError);
 
 assert.ok(test_object.hiddenValue);
 
@@ -35,8 +35,8 @@ assert.ok(propertyNames.indexOf('readonlyAccessor2') < 0);
 test_object.readwriteAccessor1 = 1;
 assert.strictEqual(test_object.readwriteAccessor1, 1);
 assert.strictEqual(test_object.readonlyAccessor1, 1);
-assert.throws(() => { test_object.readonlyAccessor1 = 3; });
+assert.throws(() => { test_object.readonlyAccessor1 = 3; }, TypeError);
 test_object.readwriteAccessor2 = 2;
 assert.strictEqual(test_object.readwriteAccessor2, 2);
 assert.strictEqual(test_object.readonlyAccessor2, 2);
-assert.throws(() => { test_object.readonlyAccessor2 = 3; });
+assert.throws(() => { test_object.readonlyAccessor2 = 3; }, TypeError);
diff --git a/test/addons-napi/test_properties/test.js b/test/addons-napi/test_properties/test.js
index fb0c19ceedb086..868c603879f1a2 100644
--- a/test/addons-napi/test_properties/test.js
+++ b/test/addons-napi/test_properties/test.js
@@ -12,7 +12,7 @@ assert.strictEqual(test_object.readwriteValue, 1);
 test_object.readwriteValue = 2;
 assert.strictEqual(test_object.readwriteValue, 2);
 
-assert.throws(() => { test_object.readonlyValue = 3; });
+assert.throws(() => { test_object.readonlyValue = 3; }, TypeError);
 
 assert.ok(test_object.hiddenValue);
 
@@ -34,8 +34,8 @@ assert.ok(propertyNames.indexOf('readonlyAccessor2') < 0);
 test_object.readwriteAccessor1 = 1;
 assert.strictEqual(test_object.readwriteAccessor1, 1);
 assert.strictEqual(test_object.readonlyAccessor1, 1);
-assert.throws(() => { test_object.readonlyAccessor1 = 3; });
+assert.throws(() => { test_object.readonlyAccessor1 = 3; }, TypeError);
 test_object.readwriteAccessor2 = 2;
 assert.strictEqual(test_object.readwriteAccessor2, 2);
 assert.strictEqual(test_object.readonlyAccessor2, 2);
-assert.throws(() => { test_object.readonlyAccessor2 = 3; });
+assert.throws(() => { test_object.readonlyAccessor2 = 3; }, TypeError);
diff --git a/test/parallel/test-assert.js b/test/parallel/test-assert.js
index 55376328b026f2..9b82c3ff4cccf9 100644
--- a/test/parallel/test-assert.js
+++ b/test/parallel/test-assert.js
@@ -522,15 +522,19 @@ testAssertionMessage({a: undefined, b: null}, '{ a: undefined, b: null }');
 testAssertionMessage({a: NaN, b: Infinity, c: -Infinity},
                      '{ a: NaN, b: Infinity, c: -Infinity }');
 
-// https://github.com/nodejs/node-v0.x-archive/issues/2893
-try {
-  // eslint-disable-next-line no-restricted-syntax
-  assert.throws(function() {
-    assert.ifError(null);
-  });
-} catch (e) {
-  threw = true;
-  assert.strictEqual(e.message, 'Missing expected exception..');
+// #2893
+{
+  let threw = false;
+  try {
+    // eslint-disable-next-line no-restricted-syntax
+    assert.throws(function() {
+      assert.ifError(null);
+    });
+  } catch (e) {
+    threw = true;
+    assert.strictEqual(e.message, 'Missing expected exception..');
+  }
+  assert.ok(threw);
 }
 assert.ok(threw);
 

From d26cbedae0909005686c804fe59d64f41c3beda2 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Mon, 10 Apr 2017 23:57:18 +0200
Subject: [PATCH 013/183] test: fix compiler warning in n-api test

Missed in ca786c3734f6e23e34cd60f13e6bdaab033c5739. This does
not actually affect the outcome because returning `nullptr` or
`this` from a constructor has the same effect.

PR-URL: https://github.com/nodejs/node/pull/12318
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 test/addons-napi/test_constructor/test_constructor.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/addons-napi/test_constructor/test_constructor.c b/test/addons-napi/test_constructor/test_constructor.c
index 23463235c315d7..0a73010d72f115 100644
--- a/test/addons-napi/test_constructor/test_constructor.c
+++ b/test/addons-napi/test_constructor/test_constructor.c
@@ -40,7 +40,7 @@ napi_value Echo(napi_env env, napi_callback_info info) {
 
 napi_value New(napi_env env, napi_callback_info info) {
   napi_value _this;
-  NAPI_CALL(env, napi_get_cb_info(env, info, NULL, NULL, NULL, &_this));
+  NAPI_CALL(env, napi_get_cb_info(env, info, NULL, NULL, &_this, NULL));
 
   return _this;
 }

From 13261d9bfec70a812d8a0b4f467ed614e595d4f2 Mon Sep 17 00:00:00 2001
From: Sampson Gao <sampsong@ca.ibm.com>
Date: Wed, 12 Apr 2017 13:36:40 -0400
Subject: [PATCH 014/183] n-api: add string api for latin1 encoding

PR-URL: https://github.com/nodejs/node/pull/12368
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
---
 src/node_api.cc                            |  78 ++++++++++--
 src/node_api.h                             |  11 ++
 test/addons-napi/test_string/test.js       |  59 ++++++++-
 test/addons-napi/test_string/test_string.c | 141 ++++++++++++++++++++-
 4 files changed, 271 insertions(+), 18 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index b20d177fba2afa..880c2d26f7480d 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -1269,6 +1269,25 @@ napi_status napi_create_array_with_length(napi_env env,
   return GET_RETURN_STATUS(env);
 }
 
+napi_status napi_create_string_latin1(napi_env env,
+                                      const char* str,
+                                      size_t length,
+                                      napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(env, result);
+
+  auto isolate = env->isolate;
+  auto str_maybe =
+      v8::String::NewFromOneByte(isolate,
+                                 reinterpret_cast<const uint8_t*>(str),
+                                 v8::NewStringType::kInternalized,
+                                 length);
+  CHECK_MAYBE_EMPTY(env, str_maybe, napi_generic_failure);
+
+  *result = v8impl::JsValueFromV8LocalValue(str_maybe.ToLocalChecked());
+  return GET_RETURN_STATUS(env);
+}
+
 napi_status napi_create_string_utf8(napi_env env,
                                     const char* str,
                                     size_t length,
@@ -1716,9 +1735,46 @@ napi_status napi_get_value_string_length(napi_env env,
   return GET_RETURN_STATUS(env);
 }
 
+// Copies a JavaScript string into a LATIN-1 string buffer. The result is the
+// number of bytes (excluding the null terminator) copied into buf.
+// A sufficient buffer size should be greater than the length of string,
+// reserving space for null terminator.
+// If bufsize is insufficient, the string will be truncated and null terminated.
+// If buf is NULL, this method returns the length of the string (in bytes)
+// via the result parameter.
+// The result argument is optional unless buf is NULL.
+napi_status napi_get_value_string_latin1(napi_env env,
+                                         napi_value value,
+                                         char* buf,
+                                         size_t bufsize,
+                                         size_t* result) {
+  NAPI_PREAMBLE(env);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+  RETURN_STATUS_IF_FALSE(env, val->IsString(), napi_string_expected);
+
+  if (!buf) {
+    CHECK_ARG(env, result);
+    *result = val.As<v8::String>()->Length();
+  } else {
+    int copied = val.As<v8::String>()->WriteOneByte(
+      reinterpret_cast<uint8_t*>(buf), 0, bufsize - 1,
+      v8::String::NO_NULL_TERMINATION);
+
+    buf[copied] = '\0';
+    if (result != nullptr) {
+      *result = copied;
+    }
+  }
+
+  return GET_RETURN_STATUS(env);
+}
+
 // Copies a JavaScript string into a UTF-8 string buffer. The result is the
-// number of bytes copied into buf, including the null terminator. If bufsize
-// is insufficient, the string will be truncated, including a null terminator.
+// number of bytes (excluding the null terminator) copied into buf.
+// A sufficient buffer size should be greater than the length of string,
+// reserving space for null terminator.
+// If bufsize is insufficient, the string will be truncated and null terminated.
 // If buf is NULL, this method returns the length of the string (in bytes)
 // via the result parameter.
 // The result argument is optional unless buf is NULL.
@@ -1737,8 +1793,10 @@ napi_status napi_get_value_string_utf8(napi_env env,
     *result = val.As<v8::String>()->Utf8Length();
   } else {
     int copied = val.As<v8::String>()->WriteUtf8(
-      buf, bufsize, nullptr, v8::String::REPLACE_INVALID_UTF8);
+      buf, bufsize - 1, nullptr, v8::String::REPLACE_INVALID_UTF8 |
+      v8::String::NO_NULL_TERMINATION);
 
+    buf[copied] = '\0';
     if (result != nullptr) {
       *result = copied;
     }
@@ -1748,10 +1806,12 @@ napi_status napi_get_value_string_utf8(napi_env env,
 }
 
 // Copies a JavaScript string into a UTF-16 string buffer. The result is the
-// number of 2-byte code units copied into buf, including the null terminator.
-// If bufsize is insufficient, the string will be truncated, including a null
-// terminator. If buf is NULL, this method returns the length of the string
-// (in 2-byte code units) via the result parameter.
+// number of 2-byte code units (excluding the null terminator) copied into buf.
+// A sufficient buffer size should be greater than the length of string,
+// reserving space for null terminator.
+// If bufsize is insufficient, the string will be truncated and null terminated.
+// If buf is NULL, this method returns the length of the string (in 2-byte
+// code units) via the result parameter.
 // The result argument is optional unless buf is NULL.
 napi_status napi_get_value_string_utf16(napi_env env,
                                         napi_value value,
@@ -1769,8 +1829,10 @@ napi_status napi_get_value_string_utf16(napi_env env,
     *result = val.As<v8::String>()->Length();
   } else {
     int copied = val.As<v8::String>()->Write(
-      reinterpret_cast<uint16_t*>(buf), 0, bufsize, v8::String::NO_OPTIONS);
+      reinterpret_cast<uint16_t*>(buf), 0, bufsize - 1,
+      v8::String::NO_NULL_TERMINATION);
 
+    buf[copied] = '\0';
     if (result != nullptr) {
       *result = copied;
     }
diff --git a/src/node_api.h b/src/node_api.h
index 8791954a377052..50b7da64c60179 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -121,6 +121,10 @@ NAPI_EXTERN napi_status napi_create_array_with_length(napi_env env,
 NAPI_EXTERN napi_status napi_create_number(napi_env env,
                                            double value,
                                            napi_value* result);
+NAPI_EXTERN napi_status napi_create_string_latin1(napi_env env,
+                                                  const char* str,
+                                                  size_t length,
+                                                  napi_value* result);
 NAPI_EXTERN napi_status napi_create_string_utf8(napi_env env,
                                                 const char* str,
                                                 size_t length,
@@ -172,6 +176,13 @@ NAPI_EXTERN napi_status napi_get_value_string_length(napi_env env,
                                                      napi_value value,
                                                      size_t* result);
 
+// Copies LATIN-1 encoded bytes from a string into a buffer.
+NAPI_EXTERN napi_status napi_get_value_string_latin1(napi_env env,
+                                                     napi_value value,
+                                                     char* buf,
+                                                     size_t bufsize,
+                                                     size_t* result);
+
 // Copies UTF-8 encoded bytes from a string into a buffer.
 NAPI_EXTERN napi_status napi_get_value_string_utf8(napi_env env,
                                                    napi_value value,
diff --git a/test/addons-napi/test_string/test.js b/test/addons-napi/test_string/test.js
index 3c9334a5616523..de6f9d98baab49 100644
--- a/test/addons-napi/test_string/test.js
+++ b/test/addons-napi/test_string/test.js
@@ -5,22 +5,67 @@ const assert = require('assert');
 // testing api calls for string
 const test_string = require(`./build/${common.buildType}/test_string`);
 
+const empty = '';
+assert.strictEqual(test_string.TestLatin1(empty), empty);
+assert.strictEqual(test_string.TestUtf8(empty), empty);
+assert.strictEqual(test_string.TestUtf16(empty), empty);
+assert.strictEqual(test_string.Length(empty), 0);
+assert.strictEqual(test_string.Utf8Length(empty), 0);
+
 const str1 = 'hello world';
-assert.strictEqual(test_string.Copy(str1), str1);
+assert.strictEqual(test_string.TestLatin1(str1), str1);
+assert.strictEqual(test_string.TestUtf8(str1), str1);
+assert.strictEqual(test_string.TestUtf16(str1), str1);
+assert.strictEqual(test_string.TestLatin1Insufficient(str1), str1.slice(0, 3));
+assert.strictEqual(test_string.TestUtf8Insufficient(str1), str1.slice(0, 3));
+assert.strictEqual(test_string.TestUtf16Insufficient(str1), str1.slice(0, 3));
 assert.strictEqual(test_string.Length(str1), 11);
 assert.strictEqual(test_string.Utf8Length(str1), 11);
 
 const str2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-assert.strictEqual(test_string.Copy(str2), str2);
+assert.strictEqual(test_string.TestLatin1(str2), str2);
+assert.strictEqual(test_string.TestUtf8(str2), str2);
+assert.strictEqual(test_string.TestUtf16(str2), str2);
+assert.strictEqual(test_string.TestLatin1Insufficient(str2), str2.slice(0, 3));
+assert.strictEqual(test_string.TestUtf8Insufficient(str2), str2.slice(0, 3));
+assert.strictEqual(test_string.TestUtf16Insufficient(str2), str2.slice(0, 3));
 assert.strictEqual(test_string.Length(str2), 62);
 assert.strictEqual(test_string.Utf8Length(str2), 62);
 
 const str3 = '?!@#$%^&*()_+-=[]{}/.,<>\'"\\';
-assert.strictEqual(test_string.Copy(str3), str3);
+assert.strictEqual(test_string.TestLatin1(str3), str3);
+assert.strictEqual(test_string.TestUtf8(str3), str3);
+assert.strictEqual(test_string.TestUtf16(str3), str3);
+assert.strictEqual(test_string.TestLatin1Insufficient(str3), str3.slice(0, 3));
+assert.strictEqual(test_string.TestUtf8Insufficient(str3), str3.slice(0, 3));
+assert.strictEqual(test_string.TestUtf16Insufficient(str3), str3.slice(0, 3));
 assert.strictEqual(test_string.Length(str3), 27);
 assert.strictEqual(test_string.Utf8Length(str3), 27);
 
-const str4 = '\u{2003}\u{2101}\u{2001}';
-assert.strictEqual(test_string.Copy(str4), str4);
-assert.strictEqual(test_string.Length(str4), 3);
-assert.strictEqual(test_string.Utf8Length(str4), 9);
+const str4 = '¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿';
+assert.strictEqual(test_string.TestLatin1(str4), str4);
+assert.strictEqual(test_string.TestUtf8(str4), str4);
+assert.strictEqual(test_string.TestUtf16(str4), str4);
+assert.strictEqual(test_string.TestLatin1Insufficient(str4), str4.slice(0, 3));
+assert.strictEqual(test_string.TestUtf8Insufficient(str4), str4.slice(0, 1));
+assert.strictEqual(test_string.TestUtf16Insufficient(str4), str4.slice(0, 3));
+assert.strictEqual(test_string.Length(str4), 31);
+assert.strictEqual(test_string.Utf8Length(str4), 62);
+
+const str5 = 'ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþ';
+assert.strictEqual(test_string.TestLatin1(str5), str5);
+assert.strictEqual(test_string.TestUtf8(str5), str5);
+assert.strictEqual(test_string.TestUtf16(str5), str5);
+assert.strictEqual(test_string.TestLatin1Insufficient(str5), str5.slice(0, 3));
+assert.strictEqual(test_string.TestUtf8Insufficient(str5), str5.slice(0, 1));
+assert.strictEqual(test_string.TestUtf16Insufficient(str5), str5.slice(0, 3));
+assert.strictEqual(test_string.Length(str5), 63);
+assert.strictEqual(test_string.Utf8Length(str5), 126);
+
+const str6 = '\u{2003}\u{2101}\u{2001}\u{202}\u{2011}';
+assert.strictEqual(test_string.TestUtf8(str6), str6);
+assert.strictEqual(test_string.TestUtf16(str6), str6);
+assert.strictEqual(test_string.TestUtf8Insufficient(str6), str6.slice(0, 1));
+assert.strictEqual(test_string.TestUtf16Insufficient(str6), str6.slice(0, 3));
+assert.strictEqual(test_string.Length(str6), 5);
+assert.strictEqual(test_string.Utf8Length(str6), 14);
diff --git a/test/addons-napi/test_string/test_string.c b/test/addons-napi/test_string/test_string.c
index c7c82d7e2e7ac6..593902edd58f9d 100644
--- a/test/addons-napi/test_string/test_string.c
+++ b/test/addons-napi/test_string/test_string.c
@@ -1,7 +1,33 @@
 #include <node_api.h>
 #include "../common.h"
 
-napi_value Copy(napi_env env, napi_callback_info info) {
+napi_value TestLatin1(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
+
+  napi_valuetype valuetype;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
+
+  NAPI_ASSERT(env, valuetype == napi_string,
+    "Wrong type of argment. Expects a string.");
+
+  char buffer[128];
+  size_t buffer_size = 128;
+  size_t copied;
+
+  NAPI_CALL(env,
+    napi_get_value_string_latin1(env, args[0], buffer, buffer_size, &copied));
+
+  napi_value output;
+  NAPI_CALL(env, napi_create_string_latin1(env, buffer, copied, &output));
+
+  return output;
+}
+
+napi_value TestUtf8(napi_env env, napi_callback_info info) {
   size_t argc = 1;
   napi_value args[1];
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
@@ -22,7 +48,111 @@ napi_value Copy(napi_env env, napi_callback_info info) {
     napi_get_value_string_utf8(env, args[0], buffer, buffer_size, &copied));
 
   napi_value output;
-  NAPI_CALL(env, napi_create_string_utf8(env, buffer, copied-1, &output));
+  NAPI_CALL(env, napi_create_string_utf8(env, buffer, copied, &output));
+
+  return output;
+}
+
+napi_value TestUtf16(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
+
+  napi_valuetype valuetype;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
+
+  NAPI_ASSERT(env, valuetype == napi_string,
+    "Wrong type of argment. Expects a string.");
+
+  char16_t buffer[128];
+  size_t buffer_size = 128;
+  size_t copied;
+
+  NAPI_CALL(env,
+    napi_get_value_string_utf16(env, args[0], buffer, buffer_size, &copied));
+
+  napi_value output;
+  NAPI_CALL(env, napi_create_string_utf16(env, buffer, copied, &output));
+
+  return output;
+}
+
+napi_value TestLatin1Insufficient(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
+
+  napi_valuetype valuetype;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
+
+  NAPI_ASSERT(env, valuetype == napi_string,
+    "Wrong type of argment. Expects a string.");
+
+  char buffer[4];
+  size_t buffer_size = 4;
+  size_t copied;
+
+  NAPI_CALL(env,
+    napi_get_value_string_latin1(env, args[0], buffer, buffer_size, &copied));
+
+  napi_value output;
+  NAPI_CALL(env, napi_create_string_latin1(env, buffer, copied, &output));
+
+  return output;
+}
+
+napi_value TestUtf8Insufficient(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
+
+  napi_valuetype valuetype;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
+
+  NAPI_ASSERT(env, valuetype == napi_string,
+    "Wrong type of argment. Expects a string.");
+
+  char buffer[4];
+  size_t buffer_size = 4;
+  size_t copied;
+
+  NAPI_CALL(env,
+    napi_get_value_string_utf8(env, args[0], buffer, buffer_size, &copied));
+
+  napi_value output;
+  NAPI_CALL(env, napi_create_string_utf8(env, buffer, copied, &output));
+
+  return output;
+}
+
+napi_value TestUtf16Insufficient(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
+
+  napi_valuetype valuetype;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
+
+  NAPI_ASSERT(env, valuetype == napi_string,
+    "Wrong type of argment. Expects a string.");
+
+  char16_t buffer[4];
+  size_t buffer_size = 4;
+  size_t copied;
+
+  NAPI_CALL(env,
+    napi_get_value_string_utf16(env, args[0], buffer, buffer_size, &copied));
+
+  napi_value output;
+  NAPI_CALL(env, napi_create_string_utf16(env, buffer, copied, &output));
 
   return output;
 }
@@ -73,7 +203,12 @@ napi_value Utf8Length(napi_env env, napi_callback_info info) {
 
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor properties[] = {
-    DECLARE_NAPI_PROPERTY("Copy", Copy),
+    DECLARE_NAPI_PROPERTY("TestLatin1", TestLatin1),
+    DECLARE_NAPI_PROPERTY("TestLatin1Insufficient", TestLatin1Insufficient),
+    DECLARE_NAPI_PROPERTY("TestUtf8", TestUtf8),
+    DECLARE_NAPI_PROPERTY("TestUtf8Insufficient", TestUtf8Insufficient),
+    DECLARE_NAPI_PROPERTY("TestUtf16", TestUtf16),
+    DECLARE_NAPI_PROPERTY("TestUtf16Insufficient", TestUtf16Insufficient),
     DECLARE_NAPI_PROPERTY("Length", Length),
     DECLARE_NAPI_PROPERTY("Utf8Length", Utf8Length),
   };

From 89e816b33641cff8fd0eb8cd2325178b97a0e0d2 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Wed, 12 Apr 2017 11:37:34 -0400
Subject: [PATCH 015/183] n-api: fix coverity scan report

Coverity was reporting _request.work_req as not being initialized.
Add memset to ensure all of _request is initialized.

PR-URL: https://github.com/nodejs/node/pull/12365
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 src/node_api.cc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/node_api.cc b/src/node_api.cc
index 880c2d26f7480d..76cc4e9d80f7a6 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -2666,6 +2666,7 @@ class Work {
     _data(data),
     _execute(execute),
     _complete(complete) {
+    memset(&_request, 0, sizeof(_request));
     _request.data = this;
   }
 

From 476b4ff9a9fddd5cc5dd91098a099687b8e8f3f4 Mon Sep 17 00:00:00 2001
From: Hitesh Kanwathirtha <hiteshk@microsoft.com>
Date: Thu, 13 Apr 2017 20:21:52 -0700
Subject: [PATCH 016/183] test: port test for make_callback to n-api

Improved test coverage for napi_make_callback by porting the
existing addons/make_callback test to n-api

PR-URL: https://github.com/nodejs/node/pull/12409
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 .../addons-napi/test_make_callback/binding.cc |  48 ++++++
 .../test_make_callback/binding.gyp            |   9 ++
 test/addons-napi/test_make_callback/test.js   |  81 ++++++++++
 .../test_make_callback_recurse/binding.cc     |  32 ++++
 .../test_make_callback_recurse/binding.gyp    |   9 ++
 .../test_make_callback_recurse/test.js        | 151 ++++++++++++++++++
 6 files changed, 330 insertions(+)
 create mode 100644 test/addons-napi/test_make_callback/binding.cc
 create mode 100644 test/addons-napi/test_make_callback/binding.gyp
 create mode 100644 test/addons-napi/test_make_callback/test.js
 create mode 100644 test/addons-napi/test_make_callback_recurse/binding.cc
 create mode 100644 test/addons-napi/test_make_callback_recurse/binding.gyp
 create mode 100644 test/addons-napi/test_make_callback_recurse/test.js

diff --git a/test/addons-napi/test_make_callback/binding.cc b/test/addons-napi/test_make_callback/binding.cc
new file mode 100644
index 00000000000000..ae17efba9b5e7d
--- /dev/null
+++ b/test/addons-napi/test_make_callback/binding.cc
@@ -0,0 +1,48 @@
+#include <node_api.h>
+#include "../common.h"
+#include <vector>
+
+namespace {
+
+napi_value MakeCallback(napi_env env, napi_callback_info info) {
+  constexpr int kMaxArgs = 10;
+  size_t argc = kMaxArgs;
+  napi_value args[kMaxArgs];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
+
+  napi_value recv = args[0];
+  napi_value func = args[1];
+
+  std::vector<napi_value> argv;
+  for (size_t n = 2; n < argc; n += 1) {
+    argv.push_back(args[n]);
+  }
+
+  napi_valuetype func_type;
+
+  NAPI_CALL(env, napi_typeof(env, func, &func_type));
+
+  napi_value result;
+  if (func_type == napi_function) {
+    NAPI_CALL(env,
+      napi_make_callback(env, recv, func, argv.size(), argv.data(), &result));
+  } else {
+    NAPI_ASSERT(env, false, "Unexpected argument type");
+  }
+
+  return result;
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_value fn;
+  NAPI_CALL_RETURN_VOID(env,
+    napi_create_function(env, NULL, MakeCallback, NULL, &fn));
+  NAPI_CALL_RETURN_VOID(env,
+    napi_set_named_property(env, exports, "makeCallback", fn));
+}
+
+}  // namespace
+
+NAPI_MODULE(binding, Init)
diff --git a/test/addons-napi/test_make_callback/binding.gyp b/test/addons-napi/test_make_callback/binding.gyp
new file mode 100644
index 00000000000000..7ede63d94a0d77
--- /dev/null
+++ b/test/addons-napi/test_make_callback/binding.gyp
@@ -0,0 +1,9 @@
+{
+  'targets': [
+    {
+      'target_name': 'binding',
+      'defines': [ 'V8_DEPRECATION_WARNINGS=1' ],
+      'sources': [ 'binding.cc' ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_make_callback/test.js b/test/addons-napi/test_make_callback/test.js
new file mode 100644
index 00000000000000..79ecb830908980
--- /dev/null
+++ b/test/addons-napi/test_make_callback/test.js
@@ -0,0 +1,81 @@
+'use strict';
+
+const common = require('../../common');
+const assert = require('assert');
+const vm = require('vm');
+const binding = require(`./build/${common.buildType}/binding`);
+const makeCallback = binding.makeCallback;
+
+function myMultiArgFunc(arg1, arg2, arg3) {
+  console.log(`MyFunc was called with ${arguments.length} arguments`);
+  assert.strictEqual(arg1, 1);
+  assert.strictEqual(arg2, 2);
+  assert.strictEqual(arg3, 3);
+  return 42;
+}
+
+assert.strictEqual(42, makeCallback(process, common.mustCall(function() {
+  assert.strictEqual(0, arguments.length);
+  assert.strictEqual(this, process);
+  return 42;
+})));
+
+assert.strictEqual(42, makeCallback(process, common.mustCall(function(x) {
+  assert.strictEqual(1, arguments.length);
+  assert.strictEqual(this, process);
+  assert.strictEqual(x, 1337);
+  return 42;
+}), 1337));
+
+assert.strictEqual(42,
+                   makeCallback(this,
+                                common.mustCall(myMultiArgFunc), 1, 2, 3));
+
+// TODO(node-api): napi_make_callback needs to support
+// strings passed for the func argument
+/*
+const recv = {
+  one: common.mustCall(function() {
+    assert.strictEqual(0, arguments.length);
+    assert.strictEqual(this, recv);
+    return 42;
+  }),
+  two: common.mustCall(function(x) {
+    assert.strictEqual(1, arguments.length);
+    assert.strictEqual(this, recv);
+    assert.strictEqual(x, 1337);
+    return 42;
+  }),
+};
+
+assert.strictEqual(42, makeCallback(recv, 'one'));
+assert.strictEqual(42, makeCallback(recv, 'two', 1337));
+
+// Check that callbacks on a receiver from a different context works.
+const foreignObject = vm.runInNewContext('({ fortytwo() { return 42; } })');
+assert.strictEqual(42, makeCallback(foreignObject, 'fortytwo'));
+*/
+
+// Check that the callback is made in the context of the receiver.
+const target = vm.runInNewContext(`
+    (function($Object) {
+      if (Object === $Object)
+        throw new Error('bad');
+      return Object;
+    })
+`);
+assert.notStrictEqual(Object, makeCallback(process, target, Object));
+
+// Runs in inner context.
+const forward = vm.runInNewContext(`
+    (function(forward) {
+      return forward(Object);
+    })
+`);
+// Runs in outer context.
+const endpoint = function($Object) {
+  if (Object === $Object)
+    throw new Error('bad');
+  return Object;
+};
+assert.strictEqual(Object, makeCallback(process, forward, endpoint));
diff --git a/test/addons-napi/test_make_callback_recurse/binding.cc b/test/addons-napi/test_make_callback_recurse/binding.cc
new file mode 100644
index 00000000000000..3f5a4c28b43524
--- /dev/null
+++ b/test/addons-napi/test_make_callback_recurse/binding.cc
@@ -0,0 +1,32 @@
+#include <node_api.h>
+#include "../common.h"
+#include <vector>
+
+namespace {
+
+napi_value MakeCallback(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value args[2];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  napi_value recv = args[0];
+  napi_value func = args[1];
+
+  napi_make_callback(env,
+    recv, func, 0 /* argc */, nullptr /* argv */, nullptr /* result */);
+
+  return recv;
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_value fn;
+  NAPI_CALL_RETURN_VOID(env,
+    napi_create_function(env, NULL, MakeCallback, NULL, &fn));
+  NAPI_CALL_RETURN_VOID(env,
+    napi_set_named_property(env, exports, "makeCallback", fn));
+}
+
+
+}  // namespace
+
+NAPI_MODULE(binding, Init)
diff --git a/test/addons-napi/test_make_callback_recurse/binding.gyp b/test/addons-napi/test_make_callback_recurse/binding.gyp
new file mode 100644
index 00000000000000..7ede63d94a0d77
--- /dev/null
+++ b/test/addons-napi/test_make_callback_recurse/binding.gyp
@@ -0,0 +1,9 @@
+{
+  'targets': [
+    {
+      'target_name': 'binding',
+      'defines': [ 'V8_DEPRECATION_WARNINGS=1' ],
+      'sources': [ 'binding.cc' ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_make_callback_recurse/test.js b/test/addons-napi/test_make_callback_recurse/test.js
new file mode 100644
index 00000000000000..895769bc33029a
--- /dev/null
+++ b/test/addons-napi/test_make_callback_recurse/test.js
@@ -0,0 +1,151 @@
+'use strict';
+
+const common = require('../../common');
+const assert = require('assert');
+const domain = require('domain');
+const binding = require(`./build/${common.buildType}/binding`);
+const makeCallback = binding.makeCallback;
+
+// Make sure this is run in the future.
+const mustCallCheckDomains = common.mustCall(checkDomains);
+
+
+// Make sure that using MakeCallback allows the error to propagate.
+assert.throws(function() {
+  makeCallback({}, function() {
+    throw new Error('hi from domain error');
+  });
+}, /^Error: hi from domain error$/);
+
+
+// Check the execution order of the nextTickQueue and MicrotaskQueue in
+// relation to running multiple MakeCallback's from bootstrap,
+// node::MakeCallback() and node::AsyncWrap::MakeCallback().
+// TODO(trevnorris): Is there a way to verify this is being run during
+// bootstrap?
+(function verifyExecutionOrder(arg) {
+  const results = [];
+
+  // Processing of the MicrotaskQueue is manually handled by node. They are not
+  // processed until after the nextTickQueue has been processed.
+  Promise.resolve(1).then(common.mustCall(function() {
+    results.push(7);
+  }));
+
+  // The nextTick should run after all immediately invoked calls.
+  process.nextTick(common.mustCall(function() {
+    results.push(3);
+
+    // Run same test again but while processing the nextTickQueue to make sure
+    // the following MakeCallback call breaks in the middle of processing the
+    // queue and allows the script to run normally.
+    process.nextTick(common.mustCall(function() {
+      results.push(6);
+    }));
+
+    makeCallback({}, common.mustCall(function() {
+      results.push(4);
+    }));
+
+    results.push(5);
+  }));
+
+  results.push(0);
+
+  // MakeCallback is calling the function immediately, but should then detect
+  // that a script is already in the middle of execution and return before
+  // either the nextTickQueue or MicrotaskQueue are processed.
+  makeCallback({}, common.mustCall(function() {
+    results.push(1);
+  }));
+
+  // This should run before either the nextTickQueue or MicrotaskQueue are
+  // processed. Previously MakeCallback would not detect this circumstance
+  // and process them immediately.
+  results.push(2);
+
+  setImmediate(common.mustCall(function() {
+    for (let i = 0; i < results.length; i++) {
+      assert.strictEqual(results[i], i,
+                         `verifyExecutionOrder(${arg}) results: ${results}`);
+    }
+    if (arg === 1) {
+      // The tests are first run on bootstrap during LoadEnvironment() in
+      // src/node.cc. Now run the tests through node::MakeCallback().
+      setImmediate(function() {
+        makeCallback({}, common.mustCall(function() {
+          verifyExecutionOrder(2);
+        }));
+      });
+    } else if (arg === 2) {
+      // setTimeout runs via the TimerWrap, which runs through
+      // AsyncWrap::MakeCallback(). Make sure there are no conflicts using
+      // node::MakeCallback() within it.
+      setTimeout(common.mustCall(function() {
+        verifyExecutionOrder(3);
+      }), 10);
+    } else if (arg === 3) {
+      mustCallCheckDomains();
+    } else {
+      throw new Error('UNREACHABLE');
+    }
+  }));
+}(1));
+
+
+function checkDomains() {
+  // Check that domains are properly entered/exited when called in multiple
+  // levels from both node::MakeCallback() and AsyncWrap::MakeCallback
+  setImmediate(common.mustCall(function() {
+    const d1 = domain.create();
+    const d2 = domain.create();
+    const d3 = domain.create();
+
+    makeCallback({domain: d1}, common.mustCall(function() {
+      assert.strictEqual(d1, process.domain);
+      makeCallback({domain: d2}, common.mustCall(function() {
+        assert.strictEqual(d2, process.domain);
+        makeCallback({domain: d3}, common.mustCall(function() {
+          assert.strictEqual(d3, process.domain);
+        }));
+        assert.strictEqual(d2, process.domain);
+      }));
+      assert.strictEqual(d1, process.domain);
+    }));
+  }));
+
+  setTimeout(common.mustCall(function() {
+    const d1 = domain.create();
+    const d2 = domain.create();
+    const d3 = domain.create();
+
+    makeCallback({domain: d1}, common.mustCall(function() {
+      assert.strictEqual(d1, process.domain);
+      makeCallback({domain: d2}, common.mustCall(function() {
+        assert.strictEqual(d2, process.domain);
+        makeCallback({domain: d3}, common.mustCall(function() {
+          assert.strictEqual(d3, process.domain);
+        }));
+        assert.strictEqual(d2, process.domain);
+      }));
+      assert.strictEqual(d1, process.domain);
+    }));
+  }), 1);
+
+  function testTimer(id) {
+    // Make sure nextTick, setImmediate and setTimeout can all recover properly
+    // after a thrown makeCallback call.
+    const d = domain.create();
+    d.on('error', common.mustCall(function(e) {
+      assert.strictEqual(e.message, `throw from domain ${id}`);
+    }));
+    makeCallback({domain: d}, function() {
+      throw new Error(`throw from domain ${id}`);
+    });
+    throw new Error('UNREACHABLE');
+  }
+
+  process.nextTick(common.mustCall(testTimer), 3);
+  setImmediate(common.mustCall(testTimer), 2);
+  setTimeout(common.mustCall(testTimer), 1, 1);
+}

From 4414e2b9c75f26c79593815c91e58c90543a2727 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Mon, 17 Apr 2017 15:52:33 -0700
Subject: [PATCH 017/183] Revert "test: port test for make_callback to n-api"

This reverts commit 70b51c8cc32f87dd016c02ac72fd998fa54e2f06.

PR-URL: https://github.com/nodejs/node/pull/12475
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 .../addons-napi/test_make_callback/binding.cc |  48 ------
 .../test_make_callback/binding.gyp            |   9 --
 test/addons-napi/test_make_callback/test.js   |  81 ----------
 .../test_make_callback_recurse/binding.cc     |  32 ----
 .../test_make_callback_recurse/binding.gyp    |   9 --
 .../test_make_callback_recurse/test.js        | 151 ------------------
 6 files changed, 330 deletions(-)
 delete mode 100644 test/addons-napi/test_make_callback/binding.cc
 delete mode 100644 test/addons-napi/test_make_callback/binding.gyp
 delete mode 100644 test/addons-napi/test_make_callback/test.js
 delete mode 100644 test/addons-napi/test_make_callback_recurse/binding.cc
 delete mode 100644 test/addons-napi/test_make_callback_recurse/binding.gyp
 delete mode 100644 test/addons-napi/test_make_callback_recurse/test.js

diff --git a/test/addons-napi/test_make_callback/binding.cc b/test/addons-napi/test_make_callback/binding.cc
deleted file mode 100644
index ae17efba9b5e7d..00000000000000
--- a/test/addons-napi/test_make_callback/binding.cc
+++ /dev/null
@@ -1,48 +0,0 @@
-#include <node_api.h>
-#include "../common.h"
-#include <vector>
-
-namespace {
-
-napi_value MakeCallback(napi_env env, napi_callback_info info) {
-  constexpr int kMaxArgs = 10;
-  size_t argc = kMaxArgs;
-  napi_value args[kMaxArgs];
-  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
-
-  NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
-
-  napi_value recv = args[0];
-  napi_value func = args[1];
-
-  std::vector<napi_value> argv;
-  for (size_t n = 2; n < argc; n += 1) {
-    argv.push_back(args[n]);
-  }
-
-  napi_valuetype func_type;
-
-  NAPI_CALL(env, napi_typeof(env, func, &func_type));
-
-  napi_value result;
-  if (func_type == napi_function) {
-    NAPI_CALL(env,
-      napi_make_callback(env, recv, func, argv.size(), argv.data(), &result));
-  } else {
-    NAPI_ASSERT(env, false, "Unexpected argument type");
-  }
-
-  return result;
-}
-
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_value fn;
-  NAPI_CALL_RETURN_VOID(env,
-    napi_create_function(env, NULL, MakeCallback, NULL, &fn));
-  NAPI_CALL_RETURN_VOID(env,
-    napi_set_named_property(env, exports, "makeCallback", fn));
-}
-
-}  // namespace
-
-NAPI_MODULE(binding, Init)
diff --git a/test/addons-napi/test_make_callback/binding.gyp b/test/addons-napi/test_make_callback/binding.gyp
deleted file mode 100644
index 7ede63d94a0d77..00000000000000
--- a/test/addons-napi/test_make_callback/binding.gyp
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  'targets': [
-    {
-      'target_name': 'binding',
-      'defines': [ 'V8_DEPRECATION_WARNINGS=1' ],
-      'sources': [ 'binding.cc' ]
-    }
-  ]
-}
diff --git a/test/addons-napi/test_make_callback/test.js b/test/addons-napi/test_make_callback/test.js
deleted file mode 100644
index 79ecb830908980..00000000000000
--- a/test/addons-napi/test_make_callback/test.js
+++ /dev/null
@@ -1,81 +0,0 @@
-'use strict';
-
-const common = require('../../common');
-const assert = require('assert');
-const vm = require('vm');
-const binding = require(`./build/${common.buildType}/binding`);
-const makeCallback = binding.makeCallback;
-
-function myMultiArgFunc(arg1, arg2, arg3) {
-  console.log(`MyFunc was called with ${arguments.length} arguments`);
-  assert.strictEqual(arg1, 1);
-  assert.strictEqual(arg2, 2);
-  assert.strictEqual(arg3, 3);
-  return 42;
-}
-
-assert.strictEqual(42, makeCallback(process, common.mustCall(function() {
-  assert.strictEqual(0, arguments.length);
-  assert.strictEqual(this, process);
-  return 42;
-})));
-
-assert.strictEqual(42, makeCallback(process, common.mustCall(function(x) {
-  assert.strictEqual(1, arguments.length);
-  assert.strictEqual(this, process);
-  assert.strictEqual(x, 1337);
-  return 42;
-}), 1337));
-
-assert.strictEqual(42,
-                   makeCallback(this,
-                                common.mustCall(myMultiArgFunc), 1, 2, 3));
-
-// TODO(node-api): napi_make_callback needs to support
-// strings passed for the func argument
-/*
-const recv = {
-  one: common.mustCall(function() {
-    assert.strictEqual(0, arguments.length);
-    assert.strictEqual(this, recv);
-    return 42;
-  }),
-  two: common.mustCall(function(x) {
-    assert.strictEqual(1, arguments.length);
-    assert.strictEqual(this, recv);
-    assert.strictEqual(x, 1337);
-    return 42;
-  }),
-};
-
-assert.strictEqual(42, makeCallback(recv, 'one'));
-assert.strictEqual(42, makeCallback(recv, 'two', 1337));
-
-// Check that callbacks on a receiver from a different context works.
-const foreignObject = vm.runInNewContext('({ fortytwo() { return 42; } })');
-assert.strictEqual(42, makeCallback(foreignObject, 'fortytwo'));
-*/
-
-// Check that the callback is made in the context of the receiver.
-const target = vm.runInNewContext(`
-    (function($Object) {
-      if (Object === $Object)
-        throw new Error('bad');
-      return Object;
-    })
-`);
-assert.notStrictEqual(Object, makeCallback(process, target, Object));
-
-// Runs in inner context.
-const forward = vm.runInNewContext(`
-    (function(forward) {
-      return forward(Object);
-    })
-`);
-// Runs in outer context.
-const endpoint = function($Object) {
-  if (Object === $Object)
-    throw new Error('bad');
-  return Object;
-};
-assert.strictEqual(Object, makeCallback(process, forward, endpoint));
diff --git a/test/addons-napi/test_make_callback_recurse/binding.cc b/test/addons-napi/test_make_callback_recurse/binding.cc
deleted file mode 100644
index 3f5a4c28b43524..00000000000000
--- a/test/addons-napi/test_make_callback_recurse/binding.cc
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <node_api.h>
-#include "../common.h"
-#include <vector>
-
-namespace {
-
-napi_value MakeCallback(napi_env env, napi_callback_info info) {
-  size_t argc = 2;
-  napi_value args[2];
-  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
-
-  napi_value recv = args[0];
-  napi_value func = args[1];
-
-  napi_make_callback(env,
-    recv, func, 0 /* argc */, nullptr /* argv */, nullptr /* result */);
-
-  return recv;
-}
-
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_value fn;
-  NAPI_CALL_RETURN_VOID(env,
-    napi_create_function(env, NULL, MakeCallback, NULL, &fn));
-  NAPI_CALL_RETURN_VOID(env,
-    napi_set_named_property(env, exports, "makeCallback", fn));
-}
-
-
-}  // namespace
-
-NAPI_MODULE(binding, Init)
diff --git a/test/addons-napi/test_make_callback_recurse/binding.gyp b/test/addons-napi/test_make_callback_recurse/binding.gyp
deleted file mode 100644
index 7ede63d94a0d77..00000000000000
--- a/test/addons-napi/test_make_callback_recurse/binding.gyp
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  'targets': [
-    {
-      'target_name': 'binding',
-      'defines': [ 'V8_DEPRECATION_WARNINGS=1' ],
-      'sources': [ 'binding.cc' ]
-    }
-  ]
-}
diff --git a/test/addons-napi/test_make_callback_recurse/test.js b/test/addons-napi/test_make_callback_recurse/test.js
deleted file mode 100644
index 895769bc33029a..00000000000000
--- a/test/addons-napi/test_make_callback_recurse/test.js
+++ /dev/null
@@ -1,151 +0,0 @@
-'use strict';
-
-const common = require('../../common');
-const assert = require('assert');
-const domain = require('domain');
-const binding = require(`./build/${common.buildType}/binding`);
-const makeCallback = binding.makeCallback;
-
-// Make sure this is run in the future.
-const mustCallCheckDomains = common.mustCall(checkDomains);
-
-
-// Make sure that using MakeCallback allows the error to propagate.
-assert.throws(function() {
-  makeCallback({}, function() {
-    throw new Error('hi from domain error');
-  });
-}, /^Error: hi from domain error$/);
-
-
-// Check the execution order of the nextTickQueue and MicrotaskQueue in
-// relation to running multiple MakeCallback's from bootstrap,
-// node::MakeCallback() and node::AsyncWrap::MakeCallback().
-// TODO(trevnorris): Is there a way to verify this is being run during
-// bootstrap?
-(function verifyExecutionOrder(arg) {
-  const results = [];
-
-  // Processing of the MicrotaskQueue is manually handled by node. They are not
-  // processed until after the nextTickQueue has been processed.
-  Promise.resolve(1).then(common.mustCall(function() {
-    results.push(7);
-  }));
-
-  // The nextTick should run after all immediately invoked calls.
-  process.nextTick(common.mustCall(function() {
-    results.push(3);
-
-    // Run same test again but while processing the nextTickQueue to make sure
-    // the following MakeCallback call breaks in the middle of processing the
-    // queue and allows the script to run normally.
-    process.nextTick(common.mustCall(function() {
-      results.push(6);
-    }));
-
-    makeCallback({}, common.mustCall(function() {
-      results.push(4);
-    }));
-
-    results.push(5);
-  }));
-
-  results.push(0);
-
-  // MakeCallback is calling the function immediately, but should then detect
-  // that a script is already in the middle of execution and return before
-  // either the nextTickQueue or MicrotaskQueue are processed.
-  makeCallback({}, common.mustCall(function() {
-    results.push(1);
-  }));
-
-  // This should run before either the nextTickQueue or MicrotaskQueue are
-  // processed. Previously MakeCallback would not detect this circumstance
-  // and process them immediately.
-  results.push(2);
-
-  setImmediate(common.mustCall(function() {
-    for (let i = 0; i < results.length; i++) {
-      assert.strictEqual(results[i], i,
-                         `verifyExecutionOrder(${arg}) results: ${results}`);
-    }
-    if (arg === 1) {
-      // The tests are first run on bootstrap during LoadEnvironment() in
-      // src/node.cc. Now run the tests through node::MakeCallback().
-      setImmediate(function() {
-        makeCallback({}, common.mustCall(function() {
-          verifyExecutionOrder(2);
-        }));
-      });
-    } else if (arg === 2) {
-      // setTimeout runs via the TimerWrap, which runs through
-      // AsyncWrap::MakeCallback(). Make sure there are no conflicts using
-      // node::MakeCallback() within it.
-      setTimeout(common.mustCall(function() {
-        verifyExecutionOrder(3);
-      }), 10);
-    } else if (arg === 3) {
-      mustCallCheckDomains();
-    } else {
-      throw new Error('UNREACHABLE');
-    }
-  }));
-}(1));
-
-
-function checkDomains() {
-  // Check that domains are properly entered/exited when called in multiple
-  // levels from both node::MakeCallback() and AsyncWrap::MakeCallback
-  setImmediate(common.mustCall(function() {
-    const d1 = domain.create();
-    const d2 = domain.create();
-    const d3 = domain.create();
-
-    makeCallback({domain: d1}, common.mustCall(function() {
-      assert.strictEqual(d1, process.domain);
-      makeCallback({domain: d2}, common.mustCall(function() {
-        assert.strictEqual(d2, process.domain);
-        makeCallback({domain: d3}, common.mustCall(function() {
-          assert.strictEqual(d3, process.domain);
-        }));
-        assert.strictEqual(d2, process.domain);
-      }));
-      assert.strictEqual(d1, process.domain);
-    }));
-  }));
-
-  setTimeout(common.mustCall(function() {
-    const d1 = domain.create();
-    const d2 = domain.create();
-    const d3 = domain.create();
-
-    makeCallback({domain: d1}, common.mustCall(function() {
-      assert.strictEqual(d1, process.domain);
-      makeCallback({domain: d2}, common.mustCall(function() {
-        assert.strictEqual(d2, process.domain);
-        makeCallback({domain: d3}, common.mustCall(function() {
-          assert.strictEqual(d3, process.domain);
-        }));
-        assert.strictEqual(d2, process.domain);
-      }));
-      assert.strictEqual(d1, process.domain);
-    }));
-  }), 1);
-
-  function testTimer(id) {
-    // Make sure nextTick, setImmediate and setTimeout can all recover properly
-    // after a thrown makeCallback call.
-    const d = domain.create();
-    d.on('error', common.mustCall(function(e) {
-      assert.strictEqual(e.message, `throw from domain ${id}`);
-    }));
-    makeCallback({domain: d}, function() {
-      throw new Error(`throw from domain ${id}`);
-    });
-    throw new Error('UNREACHABLE');
-  }
-
-  process.nextTick(common.mustCall(testTimer), 3);
-  setImmediate(common.mustCall(testTimer), 2);
-  setTimeout(common.mustCall(testTimer), 1, 1);
-}

From 7a093c26e6bccfd071cdf5d4f2a23918f9cb0aa3 Mon Sep 17 00:00:00 2001
From: Jason Ginchereau <jasongin@microsoft.com>
Date: Tue, 18 Apr 2017 15:02:00 -0700
Subject: [PATCH 018/183] n-api: remove napi_get_value_string_length()

This API doesn't serve much purpose, and is only likely to cause
confusion and bugs. The intention was that this would return the
number of characters in a string independent of encoding, but
that's not generally useful. In almost all cases, one of the
encoding-specific napi_get_value_string_* APIs is more correct.
(Pass a null buffer if only the encoded length is desired.)

Anyway the current implementation of napi_get_value_string_length()
is technically wrong: it returns the number of 2-byte code units of
the UTF-16 encoding, but there are actually some characters that
are encoded as two UTF-16 code units.

Note the JavaScript String.prototype.length property returns the
number of UTF-16 code units, which may be different from the number
of characters. So, getting the true character count is not common
with JavaScript, and is probably best left to specialized
internationalization libraries.

PR-URL: https://github.com/nodejs/node/pull/12496
Fixes: https://github.com/nodejs/abi-stable-node/issues/226
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Jeremiah Senkpiel <fishrock123@rocketmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 src/node_api.cc                            | 15 ---------------
 src/node_api.h                             |  5 -----
 test/addons-napi/test_string/test.js       | 14 +++++++-------
 test/addons-napi/test_string/test_string.c |  6 +++---
 4 files changed, 10 insertions(+), 30 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 76cc4e9d80f7a6..421765e3f0e08a 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -1720,21 +1720,6 @@ napi_status napi_get_value_bool(napi_env env, napi_value value, bool* result) {
   return napi_ok;
 }
 
-// Gets the number of CHARACTERS in the string.
-napi_status napi_get_value_string_length(napi_env env,
-                                         napi_value value,
-                                         size_t* result) {
-  NAPI_PREAMBLE(env);
-  CHECK_ARG(env, result);
-
-  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
-  RETURN_STATUS_IF_FALSE(env, val->IsString(), napi_string_expected);
-
-  *result = val.As<v8::String>()->Length();
-
-  return GET_RETURN_STATUS(env);
-}
-
 // Copies a JavaScript string into a LATIN-1 string buffer. The result is the
 // number of bytes (excluding the null terminator) copied into buf.
 // A sufficient buffer size should be greater than the length of string,
diff --git a/src/node_api.h b/src/node_api.h
index 50b7da64c60179..29c5c513f72f59 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -171,11 +171,6 @@ NAPI_EXTERN napi_status napi_get_value_bool(napi_env env,
                                             napi_value value,
                                             bool* result);
 
-// Gets the number of CHARACTERS in the string.
-NAPI_EXTERN napi_status napi_get_value_string_length(napi_env env,
-                                                     napi_value value,
-                                                     size_t* result);
-
 // Copies LATIN-1 encoded bytes from a string into a buffer.
 NAPI_EXTERN napi_status napi_get_value_string_latin1(napi_env env,
                                                      napi_value value,
diff --git a/test/addons-napi/test_string/test.js b/test/addons-napi/test_string/test.js
index de6f9d98baab49..6e4962d129a6a4 100644
--- a/test/addons-napi/test_string/test.js
+++ b/test/addons-napi/test_string/test.js
@@ -9,7 +9,7 @@ const empty = '';
 assert.strictEqual(test_string.TestLatin1(empty), empty);
 assert.strictEqual(test_string.TestUtf8(empty), empty);
 assert.strictEqual(test_string.TestUtf16(empty), empty);
-assert.strictEqual(test_string.Length(empty), 0);
+assert.strictEqual(test_string.Utf16Length(empty), 0);
 assert.strictEqual(test_string.Utf8Length(empty), 0);
 
 const str1 = 'hello world';
@@ -19,7 +19,7 @@ assert.strictEqual(test_string.TestUtf16(str1), str1);
 assert.strictEqual(test_string.TestLatin1Insufficient(str1), str1.slice(0, 3));
 assert.strictEqual(test_string.TestUtf8Insufficient(str1), str1.slice(0, 3));
 assert.strictEqual(test_string.TestUtf16Insufficient(str1), str1.slice(0, 3));
-assert.strictEqual(test_string.Length(str1), 11);
+assert.strictEqual(test_string.Utf16Length(str1), 11);
 assert.strictEqual(test_string.Utf8Length(str1), 11);
 
 const str2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
@@ -29,7 +29,7 @@ assert.strictEqual(test_string.TestUtf16(str2), str2);
 assert.strictEqual(test_string.TestLatin1Insufficient(str2), str2.slice(0, 3));
 assert.strictEqual(test_string.TestUtf8Insufficient(str2), str2.slice(0, 3));
 assert.strictEqual(test_string.TestUtf16Insufficient(str2), str2.slice(0, 3));
-assert.strictEqual(test_string.Length(str2), 62);
+assert.strictEqual(test_string.Utf16Length(str2), 62);
 assert.strictEqual(test_string.Utf8Length(str2), 62);
 
 const str3 = '?!@#$%^&*()_+-=[]{}/.,<>\'"\\';
@@ -39,7 +39,7 @@ assert.strictEqual(test_string.TestUtf16(str3), str3);
 assert.strictEqual(test_string.TestLatin1Insufficient(str3), str3.slice(0, 3));
 assert.strictEqual(test_string.TestUtf8Insufficient(str3), str3.slice(0, 3));
 assert.strictEqual(test_string.TestUtf16Insufficient(str3), str3.slice(0, 3));
-assert.strictEqual(test_string.Length(str3), 27);
+assert.strictEqual(test_string.Utf16Length(str3), 27);
 assert.strictEqual(test_string.Utf8Length(str3), 27);
 
 const str4 = '¡¢£¤¥¦§¨©ª«¬­®¯°±²³´µ¶·¸¹º»¼½¾¿';
@@ -49,7 +49,7 @@ assert.strictEqual(test_string.TestUtf16(str4), str4);
 assert.strictEqual(test_string.TestLatin1Insufficient(str4), str4.slice(0, 3));
 assert.strictEqual(test_string.TestUtf8Insufficient(str4), str4.slice(0, 1));
 assert.strictEqual(test_string.TestUtf16Insufficient(str4), str4.slice(0, 3));
-assert.strictEqual(test_string.Length(str4), 31);
+assert.strictEqual(test_string.Utf16Length(str4), 31);
 assert.strictEqual(test_string.Utf8Length(str4), 62);
 
 const str5 = 'ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþ';
@@ -59,7 +59,7 @@ assert.strictEqual(test_string.TestUtf16(str5), str5);
 assert.strictEqual(test_string.TestLatin1Insufficient(str5), str5.slice(0, 3));
 assert.strictEqual(test_string.TestUtf8Insufficient(str5), str5.slice(0, 1));
 assert.strictEqual(test_string.TestUtf16Insufficient(str5), str5.slice(0, 3));
-assert.strictEqual(test_string.Length(str5), 63);
+assert.strictEqual(test_string.Utf16Length(str5), 63);
 assert.strictEqual(test_string.Utf8Length(str5), 126);
 
 const str6 = '\u{2003}\u{2101}\u{2001}\u{202}\u{2011}';
@@ -67,5 +67,5 @@ assert.strictEqual(test_string.TestUtf8(str6), str6);
 assert.strictEqual(test_string.TestUtf16(str6), str6);
 assert.strictEqual(test_string.TestUtf8Insufficient(str6), str6.slice(0, 1));
 assert.strictEqual(test_string.TestUtf16Insufficient(str6), str6.slice(0, 3));
-assert.strictEqual(test_string.Length(str6), 5);
+assert.strictEqual(test_string.Utf16Length(str6), 5);
 assert.strictEqual(test_string.Utf8Length(str6), 14);
diff --git a/test/addons-napi/test_string/test_string.c b/test/addons-napi/test_string/test_string.c
index 593902edd58f9d..5cd6d413a679fb 100644
--- a/test/addons-napi/test_string/test_string.c
+++ b/test/addons-napi/test_string/test_string.c
@@ -157,7 +157,7 @@ napi_value TestUtf16Insufficient(napi_env env, napi_callback_info info) {
   return output;
 }
 
-napi_value Length(napi_env env, napi_callback_info info) {
+napi_value Utf16Length(napi_env env, napi_callback_info info) {
   size_t argc = 1;
   napi_value args[1];
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
@@ -171,7 +171,7 @@ napi_value Length(napi_env env, napi_callback_info info) {
     "Wrong type of argment. Expects a string.");
 
   size_t length;
-  NAPI_CALL(env, napi_get_value_string_length(env, args[0], &length));
+  NAPI_CALL(env, napi_get_value_string_utf16(env, args[0], NULL, 0, &length));
 
   napi_value output;
   NAPI_CALL(env, napi_create_number(env, (double)length, &output));
@@ -209,7 +209,7 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("TestUtf8Insufficient", TestUtf8Insufficient),
     DECLARE_NAPI_PROPERTY("TestUtf16", TestUtf16),
     DECLARE_NAPI_PROPERTY("TestUtf16Insufficient", TestUtf16Insufficient),
-    DECLARE_NAPI_PROPERTY("Length", Length),
+    DECLARE_NAPI_PROPERTY("Utf16Length", Utf16Length),
     DECLARE_NAPI_PROPERTY("Utf8Length", Utf8Length),
   };
 

From 89e85e7243c093a8572c29ed387c577963bc5dc9 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Thu, 20 Apr 2017 14:48:02 +0300
Subject: [PATCH 019/183] n-api: tighten null-checking and clean up last error

We left out null-checks for many of the parameters passed to our APIs.
In particular, arguments of type `napi_value` were often accepted
without a null-check, even though they should never be null.

Additionally, many APIs simply returned `napi_ok` on success. This
leaves in place an error that may have occurred in a previous N-API
call. Others (those which perform `NAPI_PREAMBLE(env)` at the top)
OTOH explicitly clear the last error before proceeding. With this
modification all APIs explicitly clear the last error on success.

Fixes: https://github.com/nodejs/abi-stable-node/issues/227
PR-URL: https://github.com/nodejs/node/pull/12539
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 src/node_api.cc           | 158 +++++++++++++++++++++++++++-----------
 test/addons-napi/common.h |   4 +-
 2 files changed, 114 insertions(+), 48 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 421765e3f0e08a..3e88057fba97d4 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -22,7 +22,7 @@ static
 napi_status napi_set_last_error(napi_env env, napi_status error_code,
                                 uint32_t engine_error_code = 0,
                                 void* engine_reserved = nullptr);
-void napi_clear_last_error(napi_env env);
+static napi_status napi_clear_last_error(napi_env env);
 
 struct napi_env__ {
   explicit napi_env__(v8::Isolate* _isolate): isolate(_isolate),
@@ -69,11 +69,20 @@ struct napi_env__ {
 
 #define CHECK_TO_TYPE(env, type, context, result, src, status)                \
   do {                                                                        \
+    CHECK_ARG((env), (src));                                                  \
     auto maybe = v8impl::V8LocalValueFromJsValue((src))->To##type((context)); \
     CHECK_MAYBE_EMPTY((env), maybe, (status));                                \
     (result) = maybe.ToLocalChecked();                                        \
   } while (0)
 
+#define CHECK_TO_FUNCTION(env, result, src)                                 \
+  do {                                                                      \
+    CHECK_ARG((env), (src));                                                \
+    v8::Local<v8::Value> v8value = v8impl::V8LocalValueFromJsValue((src));  \
+    RETURN_STATUS_IF_FALSE((env), v8value->IsFunction(), napi_invalid_arg); \
+    (result) = v8value.As<v8::Function>();                                  \
+  } while (0)
+
 #define CHECK_TO_OBJECT(env, context, result, src) \
   CHECK_TO_TYPE((env), Object, (context), (result), (src), napi_object_expected)
 
@@ -710,17 +719,20 @@ const char* error_messages[] = {nullptr,
                                 "An exception is pending",
                                 "The async work item was cancelled"};
 
-void napi_clear_last_error(napi_env env) {
+static napi_status napi_clear_last_error(napi_env env) {
+  CHECK_ENV(env);
+
   env->last_error.error_code = napi_ok;
 
   // TODO(boingoing): Should this be a callback?
   env->last_error.engine_error_code = 0;
   env->last_error.engine_reserved = nullptr;
+  return napi_ok;
 }
 
-napi_status napi_set_last_error(napi_env env, napi_status error_code,
-                                uint32_t engine_error_code,
-                                void* engine_reserved) {
+static napi_status napi_set_last_error(napi_env env, napi_status error_code,
+                                       uint32_t engine_error_code,
+                                       void* engine_reserved) {
   env->last_error.error_code = error_code;
   env->last_error.engine_error_code = engine_error_code;
   env->last_error.engine_reserved = engine_reserved;
@@ -731,6 +743,7 @@ napi_status napi_set_last_error(napi_env env, napi_status error_code,
 napi_status napi_get_last_error_info(napi_env env,
                                      const napi_extended_error_info** result) {
   CHECK_ENV(env);
+  CHECK_ARG(env, result);
 
   static_assert(node::arraysize(error_messages) == napi_status_last,
       "Count of error messages must match count of error values");
@@ -742,7 +755,7 @@ napi_status napi_get_last_error_info(napi_env env,
       error_messages[env->last_error.error_code];
 
   *result = &(env->last_error);
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_create_function(napi_env env,
@@ -752,6 +765,7 @@ napi_status napi_create_function(napi_env env,
                                  napi_value* result) {
   NAPI_PREAMBLE(env);
   CHECK_ARG(env, result);
+  CHECK_ARG(env, cb);
 
   v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Function> return_value;
@@ -790,6 +804,7 @@ napi_status napi_define_class(napi_env env,
                               napi_value* result) {
   NAPI_PREAMBLE(env);
   CHECK_ARG(env, result);
+  CHECK_ARG(env, constructor);
 
   v8::Isolate* isolate = env->isolate;
 
@@ -911,6 +926,8 @@ napi_status napi_set_property(napi_env env,
                               napi_value key,
                               napi_value value) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, key);
+  CHECK_ARG(env, value);
 
   v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
@@ -933,6 +950,7 @@ napi_status napi_has_property(napi_env env,
                               bool* result) {
   NAPI_PREAMBLE(env);
   CHECK_ARG(env, result);
+  CHECK_ARG(env, key);
 
   v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
@@ -954,6 +972,7 @@ napi_status napi_get_property(napi_env env,
                               napi_value key,
                               napi_value* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, key);
   CHECK_ARG(env, result);
 
   v8::Isolate* isolate = env->isolate;
@@ -977,6 +996,7 @@ napi_status napi_set_named_property(napi_env env,
                                     const char* utf8name,
                                     napi_value value) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, value);
 
   v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
@@ -1050,6 +1070,7 @@ napi_status napi_set_element(napi_env env,
                              uint32_t index,
                              napi_value value) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, value);
 
   v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
@@ -1112,11 +1133,15 @@ napi_status napi_define_properties(napi_env env,
                                    size_t property_count,
                                    const napi_property_descriptor* properties) {
   NAPI_PREAMBLE(env);
+  if (property_count > 0) {
+    CHECK_ARG(env, properties);
+  }
 
   v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  v8::Local<v8::Object> obj =
-      v8impl::V8LocalValueFromJsValue(object).As<v8::Object>();
+
+  v8::Local<v8::Object> obj;
+  CHECK_TO_OBJECT(env, context, obj, object);
 
   for (size_t i = 0; i < property_count; i++) {
     const napi_property_descriptor* p = &properties[i];
@@ -1183,6 +1208,7 @@ napi_status napi_define_properties(napi_env env,
 
 napi_status napi_is_array(napi_env env, napi_value value, bool* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
@@ -1195,6 +1221,7 @@ napi_status napi_get_array_length(napi_env env,
                                   napi_value value,
                                   uint32_t* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
@@ -1211,6 +1238,8 @@ napi_status napi_strict_equals(napi_env env,
                                napi_value rhs,
                                bool* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, lhs);
+  CHECK_ARG(env, rhs);
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> a = v8impl::V8LocalValueFromJsValue(lhs);
@@ -1345,7 +1374,7 @@ napi_status napi_get_boolean(napi_env env, bool value, napi_value* result) {
     *result = v8impl::JsValueFromV8LocalValue(v8::False(isolate));
   }
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_create_symbol(napi_env env,
@@ -1373,6 +1402,7 @@ napi_status napi_create_error(napi_env env,
                               napi_value msg,
                               napi_value* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, msg);
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> message_value = v8impl::V8LocalValueFromJsValue(msg);
@@ -1388,6 +1418,7 @@ napi_status napi_create_type_error(napi_env env,
                                    napi_value msg,
                                    napi_value* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, msg);
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> message_value = v8impl::V8LocalValueFromJsValue(msg);
@@ -1403,6 +1434,7 @@ napi_status napi_create_range_error(napi_env env,
                                     napi_value msg,
                                     napi_value* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, msg);
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> message_value = v8impl::V8LocalValueFromJsValue(msg);
@@ -1420,6 +1452,7 @@ napi_status napi_typeof(napi_env env,
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
   // JS exceptions.
   CHECK_ENV(env);
+  CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> v = v8impl::V8LocalValueFromJsValue(value);
@@ -1449,7 +1482,7 @@ napi_status napi_typeof(napi_env env,
     return napi_set_last_error(env, napi_invalid_arg);
   }
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_get_undefined(napi_env env, napi_value* result) {
@@ -1459,7 +1492,7 @@ napi_status napi_get_undefined(napi_env env, napi_value* result) {
   *result = v8impl::JsValueFromV8LocalValue(
       v8::Undefined(env->isolate));
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_get_null(napi_env env, napi_value* result) {
@@ -1469,7 +1502,7 @@ napi_status napi_get_null(napi_env env, napi_value* result) {
   *result = v8impl::JsValueFromV8LocalValue(
         v8::Null(env->isolate));
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 // Gets all callback info in a single call. (Ugly, but faster.)
@@ -1482,6 +1515,7 @@ napi_status napi_get_cb_info(
     napi_value* this_arg,  // [out] Receives the JS 'this' arg for the call
     void** data) {         // [out] Receives the data pointer for the callback.
   CHECK_ENV(env);
+  CHECK_ARG(env, cbinfo);
 
   v8impl::CallbackWrapper* info =
       reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
@@ -1500,7 +1534,7 @@ napi_status napi_get_cb_info(
     *data = info->Data();
   }
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_is_construct_call(napi_env env,
@@ -1508,13 +1542,14 @@ napi_status napi_is_construct_call(napi_env env,
                                    bool* result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because no V8 APIs are called.
   CHECK_ENV(env);
+  CHECK_ARG(env, cbinfo);
   CHECK_ARG(env, result);
 
   v8impl::CallbackWrapper* info =
       reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
 
   *result = info->IsConstructCall();
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_call_function(napi_env env,
@@ -1524,16 +1559,19 @@ napi_status napi_call_function(napi_env env,
                                const napi_value* argv,
                                napi_value* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, recv);
+  if (argc > 0) {
+    CHECK_ARG(env, argv);
+  }
 
   v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
 
   v8::Local<v8::Value> v8recv = v8impl::V8LocalValueFromJsValue(recv);
 
-  v8::Local<v8::Value> v8value = v8impl::V8LocalValueFromJsValue(func);
-  RETURN_STATUS_IF_FALSE(env, v8value->IsFunction(), napi_invalid_arg);
+  v8::Local<v8::Function> v8func;
+  CHECK_TO_FUNCTION(env, v8func, func);
 
-  v8::Local<v8::Function> v8func = v8value.As<v8::Function>();
   auto maybe = v8func->Call(context, v8recv, argc,
     reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(argv)));
 
@@ -1544,7 +1582,7 @@ napi_status napi_call_function(napi_env env,
       CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure);
       *result = v8impl::JsValueFromV8LocalValue(maybe.ToLocalChecked());
     }
-    return napi_ok;
+    return napi_clear_last_error(env);
   }
 }
 
@@ -1559,18 +1597,19 @@ napi_status napi_get_global(napi_env env, napi_value* result) {
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   *result = v8impl::JsValueFromV8LocalValue(context->Global());
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_throw(napi_env env, napi_value error) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, error);
 
   v8::Isolate* isolate = env->isolate;
 
   isolate->ThrowException(v8impl::V8LocalValueFromJsValue(error));
   // any VM calls after this point and before returning
   // to the javascript invoker will fail
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_throw_error(napi_env env, const char* msg) {
@@ -1583,7 +1622,7 @@ napi_status napi_throw_error(napi_env env, const char* msg) {
   isolate->ThrowException(v8::Exception::Error(str));
   // any VM calls after this point and before returning
   // to the javascript invoker will fail
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_throw_type_error(napi_env env, const char* msg) {
@@ -1596,7 +1635,7 @@ napi_status napi_throw_type_error(napi_env env, const char* msg) {
   isolate->ThrowException(v8::Exception::TypeError(str));
   // any VM calls after this point and before returning
   // to the javascript invoker will fail
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_throw_range_error(napi_env env, const char* msg) {
@@ -1609,19 +1648,20 @@ napi_status napi_throw_range_error(napi_env env, const char* msg) {
   isolate->ThrowException(v8::Exception::RangeError(str));
   // any VM calls after this point and before returning
   // to the javascript invoker will fail
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_is_error(napi_env env, napi_value value, bool* result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot
   // throw JS exceptions.
   CHECK_ENV(env);
+  CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
   *result = val->IsNativeError();
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_get_value_double(napi_env env,
@@ -1638,7 +1678,7 @@ napi_status napi_get_value_double(napi_env env,
 
   *result = val.As<v8::Number>()->Value();
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_get_value_int32(napi_env env,
@@ -1657,7 +1697,7 @@ napi_status napi_get_value_int32(napi_env env,
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   *result = val->Int32Value(context).ToChecked();
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_get_value_uint32(napi_env env,
@@ -1676,7 +1716,7 @@ napi_status napi_get_value_uint32(napi_env env,
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
   *result = val->Uint32Value(context).ToChecked();
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_get_value_int64(napi_env env,
@@ -1702,7 +1742,7 @@ napi_status napi_get_value_int64(napi_env env,
     *result = val->IntegerValue(context).ToChecked();
   }
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_get_value_bool(napi_env env, napi_value value, bool* result) {
@@ -1717,7 +1757,7 @@ napi_status napi_get_value_bool(napi_env env, napi_value value, bool* result) {
 
   *result = val.As<v8::Boolean>()->Value();
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 // Copies a JavaScript string into a LATIN-1 string buffer. The result is the
@@ -1734,6 +1774,7 @@ napi_status napi_get_value_string_latin1(napi_env env,
                                          size_t bufsize,
                                          size_t* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, value);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
   RETURN_STATUS_IF_FALSE(env, val->IsString(), napi_string_expected);
@@ -1769,6 +1810,7 @@ napi_status napi_get_value_string_utf8(napi_env env,
                                        size_t bufsize,
                                        size_t* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, value);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
   RETURN_STATUS_IF_FALSE(env, val->IsString(), napi_string_expected);
@@ -1804,6 +1846,7 @@ napi_status napi_get_value_string_utf16(napi_env env,
                                         size_t bufsize,
                                         size_t* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, value);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
   RETURN_STATUS_IF_FALSE(env, val->IsString(), napi_string_expected);
@@ -1830,6 +1873,7 @@ napi_status napi_coerce_to_object(napi_env env,
                                   napi_value value,
                                   napi_value* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
   v8::Isolate* isolate = env->isolate;
@@ -1845,6 +1889,7 @@ napi_status napi_coerce_to_bool(napi_env env,
                                 napi_value value,
                                 napi_value* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
   v8::Isolate* isolate = env->isolate;
@@ -1861,6 +1906,7 @@ napi_status napi_coerce_to_number(napi_env env,
                                   napi_value value,
                                   napi_value* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
   v8::Isolate* isolate = env->isolate;
@@ -1877,6 +1923,7 @@ napi_status napi_coerce_to_string(napi_env env,
                                   napi_value value,
                                   napi_value* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
   v8::Isolate* isolate = env->isolate;
@@ -1946,7 +1993,7 @@ napi_status napi_unwrap(napi_env env, napi_value js_object, void** result) {
 
   *result = unwrappedValue.As<v8::External>()->Value();
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_create_external(napi_env env,
@@ -1998,6 +2045,7 @@ napi_status napi_create_reference(napi_env env,
                                   uint32_t initial_refcount,
                                   napi_ref* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
   v8impl::Reference* reference = v8impl::Reference::New(
@@ -2017,7 +2065,7 @@ napi_status napi_delete_reference(napi_env env, napi_ref ref) {
 
   v8impl::Reference::Delete(reinterpret_cast<v8impl::Reference*>(ref));
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 // Increments the reference count, optionally returning the resulting count.
@@ -2122,6 +2170,7 @@ napi_status napi_escape_handle(napi_env env,
                                napi_value* result) {
   NAPI_PREAMBLE(env);
   CHECK_ARG(env, scope);
+  CHECK_ARG(env, escapee);
   CHECK_ARG(env, result);
 
   v8impl::EscapableHandleScopeWrapper* s =
@@ -2137,15 +2186,17 @@ napi_status napi_new_instance(napi_env env,
                               const napi_value* argv,
                               napi_value* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, constructor);
+  if (argc > 0) {
+    CHECK_ARG(env, argv);
+  }
   CHECK_ARG(env, result);
 
   v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
 
-  v8::Local<v8::Value> v8value = v8impl::V8LocalValueFromJsValue(constructor);
-  RETURN_STATUS_IF_FALSE(env, v8value->IsFunction(), napi_invalid_arg);
-
-  v8::Local<v8::Function> ctor = v8value.As<v8::Function>();
+  v8::Local<v8::Function> ctor;
+  CHECK_TO_FUNCTION(env, ctor, constructor);
 
   auto maybe = ctor->NewInstance(context, argc,
     reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(argv)));
@@ -2161,6 +2212,7 @@ napi_status napi_instanceof(napi_env env,
                             napi_value constructor,
                             bool* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, object);
   CHECK_ARG(env, result);
 
   *result = false;
@@ -2276,12 +2328,19 @@ napi_status napi_make_callback(napi_env env,
                                const napi_value* argv,
                                napi_value* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, recv);
+  if (argc > 0) {
+    CHECK_ARG(env, argv);
+  }
 
   v8::Isolate* isolate = env->isolate;
-  v8::Local<v8::Object> v8recv =
-      v8impl::V8LocalValueFromJsValue(recv).As<v8::Object>();
-  v8::Local<v8::Function> v8func =
-      v8impl::V8LocalValueFromJsValue(func).As<v8::Function>();
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+  v8::Local<v8::Object> v8recv;
+  CHECK_TO_OBJECT(env, context, v8recv, recv);
+
+  v8::Local<v8::Function> v8func;
+  CHECK_TO_FUNCTION(env, v8func, func);
 
   v8::Local<v8::Value> callback_result = node::MakeCallback(
       isolate, v8recv, v8func, argc,
@@ -2302,7 +2361,7 @@ napi_status napi_is_exception_pending(napi_env env, bool* result) {
   CHECK_ARG(env, result);
 
   *result = !env->last_exception.IsEmpty();
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_get_and_clear_last_exception(napi_env env,
@@ -2320,7 +2379,7 @@ napi_status napi_get_and_clear_last_exception(napi_env env,
     env->last_exception.Reset();
   }
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_create_buffer(napi_env env,
@@ -2399,6 +2458,7 @@ napi_status napi_create_buffer_copy(napi_env env,
 
 napi_status napi_is_buffer(napi_env env, napi_value value, bool* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
   *result = node::Buffer::HasInstance(v8impl::V8LocalValueFromJsValue(value));
@@ -2410,6 +2470,7 @@ napi_status napi_get_buffer_info(napi_env env,
                                  void** data,
                                  size_t* length) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, value);
 
   v8::Local<v8::Object> buffer =
       v8impl::V8LocalValueFromJsValue(value).As<v8::Object>();
@@ -2426,6 +2487,7 @@ napi_status napi_get_buffer_info(napi_env env,
 
 napi_status napi_is_arraybuffer(napi_env env, napi_value value, bool* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
@@ -2489,6 +2551,7 @@ napi_status napi_get_arraybuffer_info(napi_env env,
                                       void** data,
                                       size_t* byte_length) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, arraybuffer);
 
   v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(arraybuffer);
   RETURN_STATUS_IF_FALSE(env, value->IsArrayBuffer(), napi_invalid_arg);
@@ -2509,6 +2572,7 @@ napi_status napi_get_arraybuffer_info(napi_env env,
 
 napi_status napi_is_typedarray(napi_env env, napi_value value, bool* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
@@ -2524,6 +2588,7 @@ napi_status napi_create_typedarray(napi_env env,
                                    size_t byte_offset,
                                    napi_value* result) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, arraybuffer);
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(arraybuffer);
@@ -2576,6 +2641,7 @@ napi_status napi_get_typedarray_info(napi_env env,
                                      napi_value* arraybuffer,
                                      size_t* byte_offset) {
   NAPI_PREAMBLE(env);
+  CHECK_ARG(env, typedarray);
 
   v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(typedarray);
   RETURN_STATUS_IF_FALSE(env, value->IsTypedArray(), napi_invalid_arg);
@@ -2627,7 +2693,7 @@ napi_status napi_get_typedarray_info(napi_env env,
 
 namespace uvimpl {
 
-napi_status ConvertUVErrorCode(int code) {
+static napi_status ConvertUVErrorCode(int code) {
   switch (code) {
   case 0:
     return napi_ok;
@@ -2718,7 +2784,7 @@ napi_status napi_create_async_work(napi_env env,
 
   *result = reinterpret_cast<napi_async_work>(work);
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_delete_async_work(napi_env env, napi_async_work work) {
@@ -2727,7 +2793,7 @@ napi_status napi_delete_async_work(napi_env env, napi_async_work work) {
 
   uvimpl::Work::Delete(reinterpret_cast<uvimpl::Work*>(work));
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_queue_async_work(napi_env env, napi_async_work work) {
@@ -2745,7 +2811,7 @@ napi_status napi_queue_async_work(napi_env env, napi_async_work work) {
                              uvimpl::Work::ExecuteCallback,
                              uvimpl::Work::CompleteCallback));
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_cancel_async_work(napi_env env, napi_async_work work) {
@@ -2756,5 +2822,5 @@ napi_status napi_cancel_async_work(napi_env env, napi_async_work work) {
 
   CALL_UV(env, uv_cancel(reinterpret_cast<uv_req_t*>(w->Request())));
 
-  return napi_ok;
+  return napi_clear_last_error(env);
 }
diff --git a/test/addons-napi/common.h b/test/addons-napi/common.h
index b06ece6e39c7d6..676278ceaceffd 100644
--- a/test/addons-napi/common.h
+++ b/test/addons-napi/common.h
@@ -3,12 +3,12 @@
 
 #define GET_AND_THROW_LAST_ERROR(env)                                    \
   do {                                                                   \
+    const napi_extended_error_info *error_info;                          \
+    napi_get_last_error_info((env), &error_info);                        \
     bool is_pending;                                                     \
     napi_is_exception_pending((env), &is_pending);                       \
     /* If an exception is already pending, don't rethrow it */           \
     if (!is_pending) {                                                   \
-      const napi_extended_error_info* error_info;                        \
-      napi_get_last_error_info((env), &error_info);                      \
       const char* error_message = error_info->error_message != NULL ?    \
         error_info->error_message :                                      \
         "empty error message";                                           \

From 4653b671825b10d57d962785dce58f838871d6e5 Mon Sep 17 00:00:00 2001
From: Jason Ginchereau <jasongin@microsoft.com>
Date: Wed, 19 Apr 2017 14:58:58 -0700
Subject: [PATCH 020/183] n-api: Enable scope and ref APIs during exception

N-API is somewhat strict about blocking calls to many APIs while there
is a pending exception. The NAPI_PREAMBLE macro at the beginning of
many API implementations checks for a pending exception. However, a
subset of the APIs (which don't call back into JavaScript) still need
to work while in a pending-exception state. This changes the reference
APIs (equivalent to v8::Persistent) and handle scope APIs so that they
can be used for cleanup up while an exception is pending.

We may decide to similarly enable a few other APIs later, (which would
be a non-breaking change) but we know at least these are needed now
to unblock some specific scenarios.

Fixes: https://github.com/nodejs/abi-stable-node/issues/122
Fixes: https://github.com/nodejs/abi-stable-node/issues/228
PR-URL: https://github.com/nodejs/node/pull/12524
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Gabriel Schulhof <gabriel.schulhof@intel.com>
---
 src/node_api.cc                               | 60 ++++++++++++-------
 test/addons-napi/test_handle_scope/test.js    |  7 +++
 .../test_handle_scope/test_handle_scope.c     | 25 ++++++++
 3 files changed, 72 insertions(+), 20 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 3e88057fba97d4..a540284bfef99f 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -2044,7 +2044,9 @@ napi_status napi_create_reference(napi_env env,
                                   napi_value value,
                                   uint32_t initial_refcount,
                                   napi_ref* result) {
-  NAPI_PREAMBLE(env);
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ENV(env);
   CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
@@ -2052,7 +2054,7 @@ napi_status napi_create_reference(napi_env env,
       env, v8impl::V8LocalValueFromJsValue(value), initial_refcount, false);
 
   *result = reinterpret_cast<napi_ref>(reference);
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 // Deletes a reference. The referenced value is released, and may be GC'd unless
@@ -2074,7 +2076,9 @@ napi_status napi_delete_reference(napi_env env, napi_ref ref) {
 // Calling this when the refcount is 0 and the object is unavailable
 // results in an error.
 napi_status napi_reference_ref(napi_env env, napi_ref ref, uint32_t* result) {
-  NAPI_PREAMBLE(env);
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ENV(env);
   CHECK_ARG(env, ref);
 
   v8impl::Reference* reference = reinterpret_cast<v8impl::Reference*>(ref);
@@ -2084,7 +2088,7 @@ napi_status napi_reference_ref(napi_env env, napi_ref ref, uint32_t* result) {
     *result = count;
   }
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 // Decrements the reference count, optionally returning the resulting count. If
@@ -2092,7 +2096,9 @@ napi_status napi_reference_ref(napi_env env, napi_ref ref, uint32_t* result) {
 // time if there are no other references. Calling this when the refcount is
 // already 0 results in an error.
 napi_status napi_reference_unref(napi_env env, napi_ref ref, uint32_t* result) {
-  NAPI_PREAMBLE(env);
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ENV(env);
   CHECK_ARG(env, ref);
 
   v8impl::Reference* reference = reinterpret_cast<v8impl::Reference*>(ref);
@@ -2107,7 +2113,7 @@ napi_status napi_reference_unref(napi_env env, napi_ref ref, uint32_t* result) {
     *result = count;
   }
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 // Attempts to get a referenced value. If the reference is weak, the value might
@@ -2116,59 +2122,71 @@ napi_status napi_reference_unref(napi_env env, napi_ref ref, uint32_t* result) {
 napi_status napi_get_reference_value(napi_env env,
                                      napi_ref ref,
                                      napi_value* result) {
-  NAPI_PREAMBLE(env);
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ENV(env);
   CHECK_ARG(env, ref);
   CHECK_ARG(env, result);
 
   v8impl::Reference* reference = reinterpret_cast<v8impl::Reference*>(ref);
   *result = v8impl::JsValueFromV8LocalValue(reference->Get());
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_open_handle_scope(napi_env env, napi_handle_scope* result) {
-  NAPI_PREAMBLE(env);
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ENV(env);
   CHECK_ARG(env, result);
 
   *result = v8impl::JsHandleScopeFromV8HandleScope(
       new v8impl::HandleScopeWrapper(env->isolate));
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_close_handle_scope(napi_env env, napi_handle_scope scope) {
-  NAPI_PREAMBLE(env);
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ENV(env);
   CHECK_ARG(env, scope);
 
   delete v8impl::V8HandleScopeFromJsHandleScope(scope);
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_open_escapable_handle_scope(
     napi_env env,
     napi_escapable_handle_scope* result) {
-  NAPI_PREAMBLE(env);
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ENV(env);
   CHECK_ARG(env, result);
 
   *result = v8impl::JsEscapableHandleScopeFromV8EscapableHandleScope(
       new v8impl::EscapableHandleScopeWrapper(env->isolate));
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_close_escapable_handle_scope(
     napi_env env,
     napi_escapable_handle_scope scope) {
-  NAPI_PREAMBLE(env);
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ENV(env);
   CHECK_ARG(env, scope);
 
   delete v8impl::V8EscapableHandleScopeFromJsEscapableHandleScope(scope);
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_escape_handle(napi_env env,
                                napi_escapable_handle_scope scope,
                                napi_value escapee,
                                napi_value* result) {
-  NAPI_PREAMBLE(env);
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ENV(env);
   CHECK_ARG(env, scope);
   CHECK_ARG(env, escapee);
   CHECK_ARG(env, result);
@@ -2177,7 +2195,7 @@ napi_status napi_escape_handle(napi_env env,
       v8impl::V8EscapableHandleScopeFromJsEscapableHandleScope(scope);
   *result = v8impl::JsValueFromV8LocalValue(
       s->Escape(v8impl::V8LocalValueFromJsValue(escapee)));
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_new_instance(napi_env env,
@@ -2387,7 +2405,6 @@ napi_status napi_create_buffer(napi_env env,
                                void** data,
                                napi_value* result) {
   NAPI_PREAMBLE(env);
-  CHECK_ARG(env, data);
   CHECK_ARG(env, result);
 
   auto maybe = node::Buffer::New(env->isolate, length);
@@ -2397,7 +2414,10 @@ napi_status napi_create_buffer(napi_env env,
   v8::Local<v8::Object> buffer = maybe.ToLocalChecked();
 
   *result = v8impl::JsValueFromV8LocalValue(buffer);
-  *data = node::Buffer::Data(buffer);
+
+  if (data != nullptr) {
+    *data = node::Buffer::Data(buffer);
+  }
 
   return GET_RETURN_STATUS(env);
 }
diff --git a/test/addons-napi/test_handle_scope/test.js b/test/addons-napi/test_handle_scope/test.js
index ed52410f8075dd..20bee78882f071 100644
--- a/test/addons-napi/test_handle_scope/test.js
+++ b/test/addons-napi/test_handle_scope/test.js
@@ -7,4 +7,11 @@ const testHandleScope =
     require(`./build/${common.buildType}/test_handle_scope`);
 
 testHandleScope.NewScope();
+
 assert.ok(testHandleScope.NewScopeEscape() instanceof Object);
+
+assert.throws(
+  () => {
+    testHandleScope.NewScopeWithException(() => { throw new RangeError(); });
+  },
+  RangeError);
diff --git a/test/addons-napi/test_handle_scope/test_handle_scope.c b/test/addons-napi/test_handle_scope/test_handle_scope.c
index f88c04705ebdd2..6bcee16fda713e 100644
--- a/test/addons-napi/test_handle_scope/test_handle_scope.c
+++ b/test/addons-napi/test_handle_scope/test_handle_scope.c
@@ -29,10 +29,35 @@ napi_value NewScopeEscape(napi_env env, napi_callback_info info) {
   return escapee;
 }
 
+napi_value NewScopeWithException(napi_env env, napi_callback_info info) {
+  napi_handle_scope scope;
+  size_t argc;
+  napi_value exception_function;
+  napi_status status;
+  napi_value output = NULL;
+
+  NAPI_CALL(env, napi_open_handle_scope(env, &scope));
+  NAPI_CALL(env, napi_create_object(env, &output));
+
+  argc = 1;
+  NAPI_CALL(env, napi_get_cb_info(
+    env, info, &argc, &exception_function, NULL, NULL));
+
+	status = napi_call_function(
+    env, output, exception_function, 0, NULL, NULL);
+  NAPI_ASSERT(env, status == napi_pending_exception,
+    "Function should have thrown.");
+
+  // Closing a handle scope should still work while an exception is pending.
+  NAPI_CALL(env, napi_close_handle_scope(env, scope));
+  return NULL;
+}
+
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor properties[] = {
     DECLARE_NAPI_PROPERTY("NewScope", NewScope),
     DECLARE_NAPI_PROPERTY("NewScopeEscape", NewScopeEscape),
+    DECLARE_NAPI_PROPERTY("NewScopeWithException", NewScopeWithException),
   };
 
   NAPI_CALL_RETURN_VOID(env, napi_define_properties(

From f7488e7570ea2e25eb978e85c75d5cd71c2286dc Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Mon, 24 Apr 2017 18:59:09 -0400
Subject: [PATCH 021/183] test: test doc'd napi_get_value_int32 behaviour

We chose to document this in the docs as there are
different possible behaviours.  Adding this test to validate
that all vm implementations do it the same way.

PR-URL: https://github.com/nodejs/node/pull/12633
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 test/addons-napi/test_number/test.js       |  8 ++++++++
 test/addons-napi/test_number/test_number.c | 23 ++++++++++++++++++++++
 2 files changed, 31 insertions(+)

diff --git a/test/addons-napi/test_number/test.js b/test/addons-napi/test_number/test.js
index 885b9b599d9f25..b8ce6b7f995b66 100644
--- a/test/addons-napi/test_number/test.js
+++ b/test/addons-napi/test_number/test.js
@@ -37,3 +37,11 @@ assert.strictEqual(num7, test_number.Test(num7));
 
 const num8 = Number.NEGATIVE_INFINITY;
 assert.strictEqual(num8, test_number.Test(num8));
+
+
+// validate documented behaviour when value is retrieved
+// as 32 bit integer with napi_get_value_int32
+assert.strictEqual(1, test_number.TestInt32Truncation(4294967297));
+assert.strictEqual(0, test_number.TestInt32Truncation(4294967296));
+assert.strictEqual(-1, test_number.TestInt32Truncation(4294967295));
+assert.strictEqual(3, test_number.TestInt32Truncation(4294967296 * 5 + 3));
diff --git a/test/addons-napi/test_number/test_number.c b/test/addons-napi/test_number/test_number.c
index 4725ddb6a27e85..1054741d2de369 100644
--- a/test/addons-napi/test_number/test_number.c
+++ b/test/addons-napi/test_number/test_number.c
@@ -23,9 +23,32 @@ napi_value Test(napi_env env, napi_callback_info info) {
   return output;
 }
 
+napi_value TestInt32Truncation(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
+
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
+
+  NAPI_ASSERT(env, valuetype0 == napi_number,
+    "Wrong type of arguments. Expects a number as first argument.");
+
+  int32_t input;
+  NAPI_CALL(env, napi_get_value_int32(env, args[0], &input));
+
+  napi_value output;
+  NAPI_CALL(env, napi_create_number(env, input, &output));
+
+  return output;
+}
+
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("Test", Test),
+    DECLARE_NAPI_PROPERTY("TestInt32Truncation", TestInt32Truncation),
   };
 
   NAPI_CALL_RETURN_VOID(env, napi_define_properties(

From 1afabfc960eae17df50f03245d4f43ad0627fec5 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Fri, 21 Apr 2017 18:10:39 -0400
Subject: [PATCH 022/183] test: add coverage for napi_cancel_async_work

adding test coverage for napi_cancel_async_work based
on coverage report

PR-URL: https://github.com/nodejs/node/pull/12575
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 test/addons-napi/test_async/test.js       |  5 +-
 test/addons-napi/test_async/test_async.cc | 82 +++++++++++++++++++++--
 2 files changed, 80 insertions(+), 7 deletions(-)

diff --git a/test/addons-napi/test_async/test.js b/test/addons-napi/test_async/test.js
index 0bfd955ac77006..7c140d79fc054f 100644
--- a/test/addons-napi/test_async/test.js
+++ b/test/addons-napi/test_async/test.js
@@ -3,8 +3,11 @@ const common = require('../../common');
 const assert = require('assert');
 const test_async = require(`./build/${common.buildType}/test_async`);
 
-test_async(5, common.mustCall(function(err, val) {
+test_async.Test(5, common.mustCall(function(err, val) {
   assert.strictEqual(err, null);
   assert.strictEqual(val, 10);
   process.nextTick(common.mustCall(function() {}));
 }));
+
+const cancelSuceeded = function() {};
+test_async.TestCancel(common.mustCall(cancelSuceeded));
diff --git a/test/addons-napi/test_async/test_async.cc b/test/addons-napi/test_async/test_async.cc
index bc0af66d26ec61..21245e9e835659 100644
--- a/test/addons-napi/test_async/test_async.cc
+++ b/test/addons-napi/test_async/test_async.cc
@@ -7,6 +7,9 @@
 #include <unistd.h>
 #endif
 
+// this needs to be greater than the thread pool size
+#define MAX_CANCEL_THREADS 6
+
 typedef struct {
   int32_t _input;
   int32_t _output;
@@ -15,6 +18,7 @@ typedef struct {
 } carrier;
 
 carrier the_carrier;
+carrier async_carrier[MAX_CANCEL_THREADS];
 
 struct AutoHandleScope {
   explicit AutoHandleScope(napi_env env)
@@ -74,7 +78,7 @@ void Complete(napi_env env, napi_status status, void* data) {
 
   napi_value result;
   NAPI_CALL_RETURN_VOID(env,
-    napi_call_function(env, global, callback, 2, argv, &result));
+    napi_make_callback(env, global, callback, 2, argv, &result));
 
   NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, c->_callback));
   NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, c->_request));
@@ -111,12 +115,78 @@ napi_value Test(napi_env env, napi_callback_info info) {
   return nullptr;
 }
 
+void BusyCancelComplete(napi_env env, napi_status status, void* data) {
+  AutoHandleScope scope(env);
+  carrier* c = static_cast<carrier*>(data);
+  NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, c->_request));
+}
+
+void CancelComplete(napi_env env, napi_status status, void* data) {
+  AutoHandleScope scope(env);
+  carrier* c = static_cast<carrier*>(data);
+
+  if (status == napi_cancelled) {
+    // ok we got the status we expected so make the callback to
+    // indicate the cancel succeeded.
+    napi_value callback;
+    NAPI_CALL_RETURN_VOID(env,
+      napi_get_reference_value(env, c->_callback, &callback));
+    napi_value global;
+    NAPI_CALL_RETURN_VOID(env, napi_get_global(env, &global));
+    napi_value result;
+    NAPI_CALL_RETURN_VOID(env,
+      napi_make_callback(env, global, callback, 0, nullptr, &result));
+  }
+
+  NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, c->_request));
+  NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, c->_callback));
+}
+
+void CancelExecute(napi_env env, void* data) {
+#if defined _WIN32
+  Sleep(1000);
+#else
+  sleep(1);
+#endif
+}
+
+napi_value TestCancel(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value argv[1];
+  napi_value _this;
+  void* data;
+
+  // make sure the work we are going to cancel will not be
+  // able to start by using all the threads in the pool
+  for (int i = 1; i < MAX_CANCEL_THREADS; i++) {
+    NAPI_CALL(env, napi_create_async_work(env, CancelExecute,
+      BusyCancelComplete, &async_carrier[i], &async_carrier[i]._request));
+    NAPI_CALL(env, napi_queue_async_work(env, async_carrier[i]._request));
+  }
+
+  // now queue the work we are going to cancel and then cancel it.
+  // cancel will fail if the work has already started, but
+  // we have prevented it from starting by consuming all of the
+  // workers above.
+  NAPI_CALL(env,
+    napi_get_cb_info(env, info, &argc, argv, &_this, &data));
+  NAPI_CALL(env, napi_create_async_work(env, CancelExecute,
+    CancelComplete, &async_carrier[0], &async_carrier[0]._request));
+  NAPI_CALL(env,
+    napi_create_reference(env, argv[0], 1, &async_carrier[0]._callback));
+  NAPI_CALL(env, napi_queue_async_work(env, async_carrier[0]._request));
+  NAPI_CALL(env, napi_cancel_async_work(env, async_carrier[0]._request));
+  return nullptr;
+}
+
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_value test;
-  NAPI_CALL_RETURN_VOID(env,
-    napi_create_function(env, "Test", Test, nullptr, &test));
-  NAPI_CALL_RETURN_VOID(env,
-    napi_set_named_property(env, module, "exports", test));
+  napi_property_descriptor properties[] = {
+    DECLARE_NAPI_PROPERTY("Test", Test),
+    DECLARE_NAPI_PROPERTY("TestCancel", TestCancel),
+  };
+
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(properties) / sizeof(*properties), properties));
 }
 
 NAPI_MODULE(addon, Init)

From 624a44870332a210cabb930dad5b18e52f5f65ed Mon Sep 17 00:00:00 2001
From: Jason Ginchereau <jasongin@microsoft.com>
Date: Thu, 20 Apr 2017 13:01:07 -0700
Subject: [PATCH 023/183] n-api: Reference and external tests

 - Add a test project to addons-napi that covers the
   N-API reference and external APIs
 - Fix a bug in napi_typeof that was found by the new tests

PR-URL: https://github.com/nodejs/node/pull/12551
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 src/node_api.cc                               |   6 +-
 test/addons-napi/common.h                     |   3 +
 test/addons-napi/test_reference/binding.gyp   |   8 +
 test/addons-napi/test_reference/test.js       |  87 ++++++++++
 .../test_reference/test_reference.c           | 153 ++++++++++++++++++
 5 files changed, 255 insertions(+), 2 deletions(-)
 create mode 100644 test/addons-napi/test_reference/binding.gyp
 create mode 100644 test/addons-napi/test_reference/test.js
 create mode 100644 test/addons-napi/test_reference/test_reference.c

diff --git a/src/node_api.cc b/src/node_api.cc
index a540284bfef99f..11679d88716bc8 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -1465,6 +1465,10 @@ napi_status napi_typeof(napi_env env,
     // This test has to come before IsObject because IsFunction
     // implies IsObject
     *result = napi_function;
+  } else if (v->IsExternal()) {
+    // This test has to come before IsObject because IsExternal
+    // implies IsObject
+    *result = napi_external;
   } else if (v->IsObject()) {
     *result = napi_object;
   } else if (v->IsBoolean()) {
@@ -1475,8 +1479,6 @@ napi_status napi_typeof(napi_env env,
     *result = napi_symbol;
   } else if (v->IsNull()) {
     *result = napi_null;
-  } else if (v->IsExternal()) {
-    *result = napi_external;
   } else {
     // Should not get here unless V8 has added some new kind of value.
     return napi_set_last_error(env, napi_invalid_arg);
diff --git a/test/addons-napi/common.h b/test/addons-napi/common.h
index 676278ceaceffd..eae2d48b04459c 100644
--- a/test/addons-napi/common.h
+++ b/test/addons-napi/common.h
@@ -50,3 +50,6 @@
 
 #define DECLARE_NAPI_PROPERTY(name, func)                                \
   { (name), 0, (func), 0, 0, 0, napi_default, 0 }
+
+#define DECLARE_NAPI_GETTER(name, func)                                  \
+  { (name), 0, 0, (func), 0, 0, napi_default, 0 }
diff --git a/test/addons-napi/test_reference/binding.gyp b/test/addons-napi/test_reference/binding.gyp
new file mode 100644
index 00000000000000..3a6d69a65c81f5
--- /dev/null
+++ b/test/addons-napi/test_reference/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_reference",
+      "sources": [ "test_reference.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_reference/test.js b/test/addons-napi/test_reference/test.js
new file mode 100644
index 00000000000000..ddfec58f1f9d7d
--- /dev/null
+++ b/test/addons-napi/test_reference/test.js
@@ -0,0 +1,87 @@
+'use strict';
+// Flags: --expose-gc
+
+const common = require('../../common');
+const assert = require('assert');
+
+const test_reference = require(`./build/${common.buildType}/test_reference`);
+
+// This test script uses external values with finalizer callbacks
+// in order to track when values get garbage-collected. Each invocation
+// of a finalizer callback increments the finalizeCount property.
+assert.strictEqual(test_reference.finalizeCount, 0);
+
+{
+  // External value without a finalizer
+  let value = test_reference.createExternal();
+  assert.strictEqual(test_reference.finalizeCount, 0);
+  assert.strictEqual(typeof value, 'object');
+  test_reference.checkExternal(value);
+  value = null;
+  global.gc();
+  assert.strictEqual(test_reference.finalizeCount, 0);
+}
+
+{
+  // External value with a finalizer
+  let value = test_reference.createExternalWithFinalize();
+  assert.strictEqual(test_reference.finalizeCount, 0);
+  assert.strictEqual(typeof value, 'object');
+  test_reference.checkExternal(value);
+  value = null;
+  global.gc();
+  assert.strictEqual(test_reference.finalizeCount, 1);
+}
+
+{
+  // Weak reference
+  let value = test_reference.createExternalWithFinalize();
+  assert.strictEqual(test_reference.finalizeCount, 0);
+  test_reference.createReference(value, 0);
+  assert.strictEqual(test_reference.referenceValue, value);
+  value = null;
+  global.gc(); // Value should be GC'd because there is only a weak ref
+  assert.strictEqual(test_reference.referenceValue, undefined);
+  assert.strictEqual(test_reference.finalizeCount, 1);
+  test_reference.deleteReference();
+}
+
+{
+  // Strong reference
+  let value = test_reference.createExternalWithFinalize();
+  assert.strictEqual(test_reference.finalizeCount, 0);
+  test_reference.createReference(value, 1);
+  assert.strictEqual(test_reference.referenceValue, value);
+  value = null;
+  global.gc(); // Value should NOT be GC'd because there is a strong ref
+  assert.strictEqual(test_reference.finalizeCount, 0);
+  test_reference.deleteReference();
+  global.gc(); // Value should be GC'd because the strong ref was deleted
+  assert.strictEqual(test_reference.finalizeCount, 1);
+}
+
+{
+  // Strong reference, increment then decrement to weak reference
+  let value = test_reference.createExternalWithFinalize();
+  assert.strictEqual(test_reference.finalizeCount, 0);
+  test_reference.createReference(value, 1);
+  value = null;
+  global.gc(); // Value should NOT be GC'd because there is a strong ref
+  assert.strictEqual(test_reference.finalizeCount, 0);
+
+  assert.strictEqual(test_reference.incrementRefcount(), 2);
+  global.gc(); // Value should NOT be GC'd because there is a strong ref
+  assert.strictEqual(test_reference.finalizeCount, 0);
+
+  assert.strictEqual(test_reference.decrementRefcount(), 1);
+  global.gc(); // Value should NOT be GC'd because there is a strong ref
+  assert.strictEqual(test_reference.finalizeCount, 0);
+
+  assert.strictEqual(test_reference.decrementRefcount(), 0);
+  global.gc(); // Value should be GC'd because the ref is now weak!
+  assert.strictEqual(test_reference.finalizeCount, 1);
+
+  test_reference.deleteReference();
+  global.gc(); // Value was already GC'd
+  assert.strictEqual(test_reference.finalizeCount, 1);
+}
diff --git a/test/addons-napi/test_reference/test_reference.c b/test/addons-napi/test_reference/test_reference.c
new file mode 100644
index 00000000000000..1a238a560aac53
--- /dev/null
+++ b/test/addons-napi/test_reference/test_reference.c
@@ -0,0 +1,153 @@
+#include <node_api.h>
+#include "../common.h"
+#include <stdlib.h>
+
+static int test_value = 1;
+static int finalize_count = 0;
+static napi_ref test_reference = NULL;
+
+napi_value GetFinalizeCount(napi_env env, napi_callback_info info) {
+  napi_value result;
+  NAPI_CALL(env, napi_create_number(env, finalize_count, &result));
+  return result;
+}
+
+void FinalizeExternal(napi_env env, void* data, void* hint) {
+  free(data);
+  finalize_count++;
+}
+
+napi_value CreateExternal(napi_env env, napi_callback_info info) {
+  int* data = &test_value;
+
+  napi_value result;
+  NAPI_CALL(env,
+    napi_create_external(env,
+                         data,
+                         NULL, /* finalize_cb */
+                         NULL, /* finalize_hint */
+                         &result));
+
+  finalize_count = 0;
+  return result;
+}
+
+napi_value CreateExternalWithFinalize(napi_env env, napi_callback_info info) {
+  int* data = malloc(sizeof(int));
+  *data = test_value;
+
+  napi_value result;
+  NAPI_CALL(env,
+    napi_create_external(env,
+                         data,
+                         FinalizeExternal,
+                         NULL, /* finalize_hint */
+                         &result));
+
+  finalize_count = 0;
+  return result;
+}
+
+napi_value CheckExternal(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value arg;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &arg, NULL, NULL));
+
+  NAPI_ASSERT(env, argc == 1, "Expected one argument.");
+
+  napi_valuetype argtype;
+  NAPI_CALL(env, napi_typeof(env, arg, &argtype));
+
+  NAPI_ASSERT(env, argtype == napi_external, "Expected an external value.")
+
+  int* data;
+  NAPI_CALL(env, napi_get_value_external(env, arg, &data));
+
+  NAPI_ASSERT(env, data != NULL && *data == test_value,
+    "An external data value of 1 was expected.")
+
+  return NULL;
+}
+
+napi_value CreateReference(napi_env env, napi_callback_info info) {
+  NAPI_ASSERT(env, test_reference == NULL,
+    "The test allows only one reference at a time.");
+
+  size_t argc = 2;
+  napi_value args[2];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+  NAPI_ASSERT(env, argc == 2, "Expected two arguments.");
+
+  uint32_t initial_refcount;
+  NAPI_CALL(env, napi_get_value_uint32(env, args[1], &initial_refcount));
+
+  NAPI_CALL(env,
+    napi_create_reference(env, args[0], initial_refcount, &test_reference));
+
+  NAPI_ASSERT(env, test_reference != NULL,
+    "A reference should have been created.");
+
+  return NULL;
+}
+
+napi_value DeleteReference(napi_env env, napi_callback_info info) {
+  NAPI_ASSERT(env, test_reference != NULL,
+    "A reference must have been created.");
+
+  NAPI_CALL(env, napi_delete_reference(env, test_reference));
+  test_reference = NULL;
+  return NULL;
+}
+
+napi_value IncrementRefcount(napi_env env, napi_callback_info info) {
+  NAPI_ASSERT(env, test_reference != NULL,
+    "A reference must have been created.");
+
+  uint32_t refcount;
+  NAPI_CALL(env, napi_reference_ref(env, test_reference, &refcount));
+
+  napi_value result;
+  NAPI_CALL(env, napi_create_number(env, refcount, &result));
+  return result;
+}
+
+napi_value DecrementRefcount(napi_env env, napi_callback_info info) {
+  NAPI_ASSERT(env, test_reference != NULL,
+    "A reference must have been created.");
+
+  uint32_t refcount;
+  NAPI_CALL(env, napi_reference_unref(env, test_reference, &refcount));
+
+  napi_value result;
+  NAPI_CALL(env, napi_create_number(env, refcount, &result));
+  return result;
+}
+
+napi_value GetReferenceValue(napi_env env, napi_callback_info info) {
+  NAPI_ASSERT(env, test_reference != NULL,
+    "A reference must have been created.");
+
+  napi_value result;
+  NAPI_CALL(env, napi_get_reference_value(env, test_reference, &result));
+  return result;
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_property_descriptor descriptors[] = {
+    DECLARE_NAPI_GETTER("finalizeCount", GetFinalizeCount),
+    DECLARE_NAPI_PROPERTY("createExternal", CreateExternal),
+    DECLARE_NAPI_PROPERTY("createExternalWithFinalize",
+      CreateExternalWithFinalize),
+    DECLARE_NAPI_PROPERTY("checkExternal", CheckExternal),
+    DECLARE_NAPI_PROPERTY("createReference", CreateReference),
+    DECLARE_NAPI_PROPERTY("deleteReference", DeleteReference),
+    DECLARE_NAPI_PROPERTY("incrementRefcount", IncrementRefcount),
+    DECLARE_NAPI_PROPERTY("decrementRefcount", DecrementRefcount),
+    DECLARE_NAPI_GETTER("referenceValue", GetReferenceValue),
+  };
+
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+}
+
+NAPI_MODULE(addon, Init)

From 406f4ce83f89757bf15f437d7f1850ce6afbd2b7 Mon Sep 17 00:00:00 2001
From: Jason Ginchereau <jasongin@microsoft.com>
Date: Wed, 26 Apr 2017 09:51:15 -0700
Subject: [PATCH 024/183] n-api: Sync with back-compat changes

Background: To enable N-API support for node versions back to v4, the
N-API code can also be built as an external addon. To make maintenance
easier, a single codebase needs to support both built-in and external
scenarios, along with Node versions >= 4 (and corresponding V8
versions).

This change includes several minor fixes to avoid using node
internal APIs and support older V8 versions:
  - Expand node::arraysize
  - In the CHECK_ENV() macro, return an error code instead of calling
    node::FatalError(). This is more consistent with how other invalid
    arguments to N-API functions are handled.
  - In v8impl::SetterCallbackWrapper::SetReturnValue(), do nothing
    instead of calling node::FatalError(). This is more consistent
    with JavaScript setter callbacks, where any returned value is
    silently ignored.
  - When queueing async work items, get the uv default loop instead of
    getting the loop from node::Environment::GetCurrent(). Currently
    that returns the same loop anyway. If/when node supports multiple
    environments, it should have a public API for getting the
    environment & event loop, and we can update this implementation
    then.
  - Use v8::Maybe::FromJust() instead of the newer alias ToChecked()

PR-URL: https://github.com/nodejs/node/pull/12674
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 src/node_api.cc | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 11679d88716bc8..d1ca7bec27c269 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -12,8 +12,10 @@
 #include <node_object_wrap.h>
 #include <string.h>
 #include <algorithm>
+#include <cassert>
 #include <cmath>
 #include <vector>
+#include "uv.h"
 #include "node_api.h"
 #include "env-inl.h"
 #include "node_api_backport.h"
@@ -45,9 +47,9 @@ struct napi_env__ {
     }                                                                   \
   } while (0)
 
-#define CHECK_ENV(env)                                               \
-  if ((env) == nullptr) {                                            \
-    node::FatalError(__func__, "environment(env) must not be null"); \
+#define CHECK_ENV(env)        \
+  if ((env) == nullptr) {     \
+    return napi_invalid_arg;  \
   }
 
 #define CHECK_ARG(env, arg) \
@@ -581,8 +583,7 @@ class SetterCallbackWrapper
 
   /*virtual*/
   void SetReturnValue(napi_value value) override {
-    node::FatalError("napi_set_return_value",
-      "Cannot return a value from a setter callback.");
+    // Ignore any value returned from a setter callback.
   }
 
  private:
@@ -745,7 +746,8 @@ napi_status napi_get_last_error_info(napi_env env,
   CHECK_ENV(env);
   CHECK_ARG(env, result);
 
-  static_assert(node::arraysize(error_messages) == napi_status_last,
+  static_assert(
+      (sizeof (error_messages) / sizeof (*error_messages)) == napi_status_last,
       "Count of error messages must match count of error values");
   assert(env->last_error.error_code < napi_status_last);
 
@@ -1697,7 +1699,7 @@ napi_status napi_get_value_int32(napi_env env,
 
   v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  *result = val->Int32Value(context).ToChecked();
+  *result = val->Int32Value(context).FromJust();
 
   return napi_clear_last_error(env);
 }
@@ -1716,7 +1718,7 @@ napi_status napi_get_value_uint32(napi_env env,
 
   v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  *result = val->Uint32Value(context).ToChecked();
+  *result = val->Uint32Value(context).FromJust();
 
   return napi_clear_last_error(env);
 }
@@ -1741,7 +1743,7 @@ napi_status napi_get_value_int64(napi_env env,
   } else {
     v8::Isolate* isolate = env->isolate;
     v8::Local<v8::Context> context = isolate->GetCurrentContext();
-    *result = val->IntegerValue(context).ToChecked();
+    *result = val->IntegerValue(context).FromJust();
   }
 
   return napi_clear_last_error(env);
@@ -2822,9 +2824,11 @@ napi_status napi_queue_async_work(napi_env env, napi_async_work work) {
   CHECK_ENV(env);
   CHECK_ARG(env, work);
 
-  // Consider: Encapsulate the uv_loop_t into an opaque pointer parameter
-  uv_loop_t* event_loop =
-    node::Environment::GetCurrent(env->isolate)->event_loop();
+  // Consider: Encapsulate the uv_loop_t into an opaque pointer parameter.
+  // Currently the environment event loop is the same as the UV default loop.
+  // Someday (if node ever supports multiple isolates), it may be better to get
+  // the loop from node::Environment::GetCurrent(env->isolate)->event_loop();
+  uv_loop_t* event_loop = uv_default_loop();
 
   uvimpl::Work* w = reinterpret_cast<uvimpl::Work*>(work);
 

From 9189c86154ac884495104eeeaba93b6f7b5faec8 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Wed, 19 Apr 2017 18:26:24 -0400
Subject: [PATCH 025/183] doc: Add initial documentation for N-API

Add the initial documentation for the N-API

This PR is a result of work in the abi-stable-node repo:
https://github.com/nodejs/abi-stable-node/tree/doc,
with this PR being the cumulative work on the documentation
sections in that repo with the following contributors
in alphabetical order:

Author: Arunesh Chandra <arunesh.chandra@microsoft.com>
Author: Gabriel Schulhof <gabriel.schulhof@intel.com>
Author: Hitesh Kanwathirtha <hiteshk@microsoft.com>
Author: Jason Ginchereau <jasongin@microsoft.com>
Author: Michael Dawson <michael_dawson@ca.ibm.com>
Author: Sampson Gao <sampsong@ca.ibm.com>
Author: Taylor Woll <taylor.woll@microsoft.com>

PR-URL: https://github.com/nodejs/node/pull/12549
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jeremiah Senkpiel <fishrock123@rocketmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 doc/api/_toc.md   |    1 +
 doc/api/addons.md |   20 +
 doc/api/n-api.md  | 2998 +++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 3019 insertions(+)
 create mode 100644 doc/api/n-api.md

diff --git a/doc/api/_toc.md b/doc/api/_toc.md
index 5f7bca59e87d75..034844110a1fe7 100644
--- a/doc/api/_toc.md
+++ b/doc/api/_toc.md
@@ -8,6 +8,7 @@
 * [Assertion Testing](assert.html)
 * [Buffer](buffer.html)
 * [C/C++ Addons](addons.html)
+* [C/C++ Addons - N-API](n-api.html)
 * [Child Processes](child_process.html)
 * [Cluster](cluster.html)
 * [Command Line Options](cli.html)
diff --git a/doc/api/addons.md b/doc/api/addons.md
index 17811245f1c23e..d7ede4ca23ae22 100644
--- a/doc/api/addons.md
+++ b/doc/api/addons.md
@@ -215,6 +215,26 @@ Addon developers are recommended to use to keep compatibility between past and
 future releases of V8 and Node.js. See the `nan` [examples][] for an
 illustration of how it can be used.
 
+
+## N-API
+
+> Stability: 1 - Experimental
+
+N-API is an API for building native Addons. It is independent from
+the underlying JavaScript runtime (ex V8) and is maintained as part of
+Node.js itself. This API will be Application Binary Interface (ABI) stable
+across version of Node.js. It is intended to insulate Addons from
+changes in the underlying JavaScript engine and allow modules
+compiled for one version to run on later versions of Node.js without
+recompilation. Addons are built/packaged with the same approach/tools
+outlined in this document (node-gyp, etc.). The only difference is the
+set of APIs that are used by the native code. Instead of using the V8
+or [Native Abstractions for Node.js][] APIs, the functions available
+in the N-API are used.
+
+The functions available and how to use them are documented in the
+section titled [C/C++ Addons - N-API](n-api.html).
+
 ## Addon examples
 
 Following are some example Addons intended to help developers get started. The
diff --git a/doc/api/n-api.md b/doc/api/n-api.md
new file mode 100644
index 00000000000000..f9e47a7b8d32a0
--- /dev/null
+++ b/doc/api/n-api.md
@@ -0,0 +1,2998 @@
+# N-API
+
+> Stability: 1 - Experimental
+
+N-API (pronounced N as in the letter, followed by API)
+is an API for building native Addons. It is independent from
+the underlying JavaScript runtime (ex V8) and is maintained as part of
+Node.js itself. This API will be Application Binary Interface (ABI) stable
+across versions of Node.js. It is intended to insulate Addons from
+changes in the underlying JavaScript engine and allow modules
+compiled for one version to run on later versions of Node.js without
+recompilation.
+
+Addons are built/packaged with the same approach/tools
+outlined in the section titled  [C/C++ Addons](addons.html).
+The only difference is the set of APIs that are used by the native code.
+Instead of using the V8 or [Native Abstractions for Node.js][] APIs,
+the functions available in the N-API are used.
+
+APIs exposed by N-API are generally used to create and manipulate
+JavaScript values. Concepts and operations generally map to ideas specified
+in the ECMA262 Language Specification. The APIs have the following
+properties:
+- All N-API calls return a status code of type `napi_status`. This
+  status indicates whether the API call succeeded or failed.
+- The API's return value is passed via an out parameter.
+- All JavaScript values are abstracted behind an opaque type named
+  `napi_value`.
+- In case of an error status code, additional information can be obtained
+  using `napi_get_last_error_info`. More information can be found in the error
+  handling section [Error Handling][].
+
+The documentation for N-API is structured as follows:
+
+* [Basic N-API Data Types][]
+* [Error Handling][]
+* [Object Lifetime Management][]
+* [Module Registration][]
+* [Working with JavaScript Values][]
+* [Working with JavaScript Values - Abstract Operations][]
+* [Working with JavaScript Properties][]
+* [Working with JavaScript Functions][]
+* [Object Wrap][]
+* [Aynchronous Operations][]
+
+The N-API is a C API that ensures ABI stability across Node.js versions
+and different compiler levels. However, we also understand that a C++
+API can be easier to use in many cases. To support these cases we expect
+there to be one or more C++ wrapper modules that provide an inlineable C++
+API. Binaries built with these wrapper modules will depend on the symbols
+for the N-API C based functions exported by Node.js. These wrappers are not
+part of N-API, nor will they be maintained as part of Node.js. One such
+example is: [node-api](https://github.com/nodejs/node-api).
+
+## Basic N-API Data Types
+
+N-API exposes the following fundamental datatypes as abstractions that are
+consumed by the various APIs. These APIs should be treated as opaque,
+introspectable only with other N-API calls.
+
+### *napi_status*
+Integral status code indicating the success or failure of a N-API call.
+Currently, the following status codes are supported.
+```C
+typedef enum {
+  napi_ok,
+  napi_invalid_arg,
+  napi_object_expected,
+  napi_string_expected,
+  napi_name_expected,
+  napi_function_expected,
+  napi_number_expected,
+  napi_boolean_expected,
+  napi_array_expected,
+  napi_generic_failure,
+  napi_pending_exception,
+  napi_cancelled,
+  napi_status_last
+} napi_status;
+```
+If additional information is required upon an API returning a failed status,
+it can be obtained by calling `napi_get_last_error_info`.
+
+### *napi_extended_error_info*
+```C
+typedef struct {
+  const char* error_message;
+  void* engine_reserved;
+  uint32_t engine_error_code;
+  napi_status error_code;
+} napi_extended_error_info;
+```
+
+- `error_message`: UTF8-encoded string containing a VM-neutral description of
+  the error.
+- `engine_reserved`: Reserved for VM-specific error details. This is currently
+  not implemented for any VM.
+- `engine_error_code`: VM-specific error code. This is currently
+  not implemented for any VM.
+- `error_code`: The N-API status code that originated with the last error.
+
+See the [Error Handling][] section for additional information.
+
+### *napi_env*
+`napi_env` is used to represent a context that the underlying N-API
+implementation can use to persist VM-specific state. This structure is passed
+to native functions when they're invoked, and it must be passed back when
+making N-API calls. Specifically, the same `napi_env` that was passed in when
+the initial native function was called must be passed to any subsequent
+nested N-API calls. Caching the `napi_env` for the purpose of general reuse is
+not allowed.
+
+### *napi_value*
+This is an opaque pointer that is used to represent a JavaScript value.
+
+### N-API Memory Management types
+#### *napi_handle_scope*
+This is an abstraction used to control and modify the lifetime of objects
+created within a particular scope. In general, N-API values are created within
+the context of a handle scope. When a native method is called from
+JavaScript, a default handle scope will exist. If the user does not explicitly
+create a new handle scope, N-API values will be created in the default handle
+scope. For any invocations of code outside the execution of a native method
+(for instance, during a libuv callback invocation), the module is required to
+create a scope before invoking any functions that can result in the creation
+of JavaScript values.
+
+Handle scopes are created using [`napi_open_handle_scope`][] and are destroyed
+using [`napi_close_handle_scope`][]. Closing the scope can indicate to the GC that
+all `napi_value`s created during the lifetime of the handle scope are no longer
+referenced from the current stack frame.
+
+For more details, review the [Object Lifetime Management][].
+
+#### *napi_escapable_handle_scope*
+Escapable handle scopes are a special type of handle scope to return values
+created within a particular handle scope to a parent scope.
+
+#### *napi_ref*
+This is the abstraction to use to reference a `napi_value`. This allows for
+users to manage the lifetimes of JavaScript values, including defining their
+minimum lifetimes explicitly.
+
+For more details, review the [Object Lifetime Management][].
+
+### N-API Callback types
+#### *napi_callback_info*
+Opaque datatype that is passed to a callback function. It can be used for two
+purposes:
+- Get additional information about the context in which the callback was
+  invoked.
+- Set the return value of the callback.
+
+#### *napi_callback*
+Function pointer type for user-provided native functions which are to be
+exposed to JavaScript via N-API. Callback functions should satisfy the
+following signature:
+```C
+typedef void (*napi_callback)(napi_env, napi_callback_info);
+```
+
+#### *napi_finalize*
+Function pointer type for add-on provided functions that allow the user to be
+notified when externally-owned data is ready to be cleaned up because the
+object with which it was associated with, has been garbage-collected. The user
+must provide a function satisfying the following signature which would get
+called upon the object's collection. Currently, `napi_finalize` can be used for
+finding out when objects that have external data are collected.
+
+
+#### napi_async_execute_callback
+Function pointer used with functions that support asynchronous
+operations. Callback functions must statisfy the following signature:
+
+```C
+typedef void (*napi_async_execute_callback)(napi_env env, void* data);
+```
+
+#### napi_async_complete_callback
+Function pointer used with functions that support asynchronous
+operations. Callback functions must statisfy the following signature:
+
+```C
+typedef void (*napi_async_complete_callback)(napi_env env,
+                                             napi_status status,
+                                             void* data);
+```
+
+## Error Handling
+N-API uses both return values and Javascript exceptions for error handling.
+The following sections explain the approach for each case.
+
+### Return values
+All of the N-API functions share the same error handling pattern. The
+return type of all API functions is `napi_status`.
+
+The return value will be `napi_ok` if the request was successful and
+no uncaught JavaScript exception was thrown. If an error occurred AND
+an exception was thrown, the `napi_status` value for the error
+will be returned. If an exception was thrown, and no error occurred,
+`napi_pending_exception` will be returned.
+
+In cases where a return value other than `napi_ok` or
+`napi_pending_exception` is returned, [`napi_is_exception_pending`][]
+must be called to check if an exception is pending.
+See the section on exceptions for more details.
+
+The full set of possible napi_status values is defined
+in `napi_api_types.h`.
+
+The `napi_status` return value provides a VM-independent representation of
+the error which occurred. In some cases it is useful to be able to get
+more detailed information, including a string representing the error as well as
+VM (engine)-specific information.
+
+In order to retrieve this information [`napi_get_last_error_info`][]
+is provided which returns a `napi_extended_error_info` structure.
+The format of the `napi_extended_error_info` structure is as follows:
+
+```C
+typedef struct napi_extended_error_info {
+  const char* error_message;
+  void* engine_reserved;
+  uint32_t engine_error_code;
+  napi_status error_code;
+};
+```
+- `error_message`: Textual representation of the error that occured.
+- `engine_reserved`: Opaque handle reserved for engine use only.
+- `engine_error_code`: VM specific error code.
+- `error_code`: n-api status code for the last error.
+
+[`napi_get_last_error_info`][] returns the information for the last
+N-API call that was made.
+
+**Note:** Do not rely on the content or format of any of the extended
+information as it is not subject to SemVer and may change at any time.
+It is intended only for logging purposes.
+
+#### napi_get_last_error_info
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NAPI_EXTERN napi_status
+napi_get_last_error_info(napi_env env,
+                         const napi_extended_error_info** result);
+```
+- `[in] env`: The environment that the API is invoked under.
+- `[out] result`: The `napi_extended_error_info` structure with more
+information about the error.
+
+Returns `napi_ok` if the API succeeded.
+
+This API retrieves a `napi_extended_error_info` structure with information
+about the last error that occured.
+
+**Note:** Do not rely on the content or format of any of the extended
+information as it is not subject to SemVer and may change at any time.
+It is intended only for logging purposes.
+
+
+### Exceptions
+Any N-API function call may result in a pending JavaScript exception. This is
+obviously the case for any function that may cause the execution of
+JavaScript, but N-API specifies that an exception may be pending
+on return from any of the API functions.
+
+If the `napi_status` returned by a function is `napi_ok` then no
+exception is pending and no additional action is required. If the
+`napi_status` returned is anything other than `napi_ok` or
+`napi_pending_exception`, in order to try to recover and continue
+instead of simply returning immediately, [`napi_is_exception_pending`][]
+must be called in order to determine if an exception is pending or not.
+
+When an exception is pending one of two approaches can be employed.
+
+The first appoach is to do any appropriate cleanup and then return so that
+execution will return to JavaScript. As part of the transition back to
+JavaScript the exception will be thrown at the point in the JavaScript
+code where the native method was invoked. The behavior of most N-API calls
+is unspecified while an exception is pending, and many will simply return
+`napi_pending_exception`, so it is important to do as little as possible
+and then return to JavaScript where the exception can be handled.
+
+The second approach is to try to handle the exception. There will be cases
+where the native code can catch the exception, take the appropriate action,
+and then continue. This is only recommended in specific cases
+where it is known that the exception can be safely handled. In these
+cases [`napi_get_and_clear_last_exception`][] can be used to get and
+clear the exception.  On success, result will contain the handle to
+the last JavaScript Object thrown. If it is determined, after
+retrieving the exception, the exception cannot be handled after all
+it can be re-thrown it with [`napi_throw`][] where error is the
+JavaScript Error object to be thrown.
+
+The following utility functions are also available in case native code
+needs to throw an exception or determine if a `napi_value` is an instance
+of a JavaScript `Error` object:  [`napi_throw_error`][],
+[`napi_throw_type_error`][], [`napi_throw_range_error`][] and
+[`napi_is_error`][].
+
+The following utility functions are also available in case native
+code needs to create an Error object: [`napi_create_error`][],
+[`napi_create_type_error`][], and [`napi_create_range_error`][].
+where result is the napi_value that refers to the newly created
+JavaScript Error object.
+
+#### napi_throw
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NODE_EXTERN napi_status napi_throw(napi_env env, napi_value error);
+```
+- `[in] env`: The environment that the API is invoked under.
+- `[in] error`: The `napi_value` for the Error to be thrown.
+
+Returns `napi_ok` if the API succeeded.
+
+This API throws the JavaScript Error provided.
+
+
+#### napi_throw_error
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NODE_EXTERN napi_status napi_throw_error(napi_env env, const char* msg);
+```
+- `[in] env`: The environment that the API is invoked under.
+- `[in] msg`: C string representing the text to be associated with
+the error.
+
+Returns `napi_ok` if the API succeeded.
+
+This API throws a JavaScript Error with the text provided.
+
+#### napi_throw_type_error
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NODE_EXTERN napi_status napi_throw_type_error(napi_env env, const char* msg);
+```
+- `[in] env`: The environment that the API is invoked under.
+- `[in] msg`: C string representing the text to be associated with
+the error.
+
+Returns `napi_ok` if the API succeeded.
+
+This API throws a JavaScript TypeError with the text provided.
+
+#### napi_throw_range_error
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NODE_EXTERN napi_status napi_throw_range_error(napi_env env, const char* msg);
+```
+- `[in] env`: The environment that the API is invoked under.
+- `[in] msg`: C string representing the text to be associated with
+the error.
+
+Returns `napi_ok` if the API succeeded.
+
+This API throws a JavaScript RangeError with the text provided.
+
+
+#### napi_is_error
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NODE_EXTERN napi_status napi_is_error(napi_env env,
+                                      napi_value value,
+                                      bool* result);
+```
+- `[in] env`: The environment that the API is invoked under.
+- `[in] msg`: The `napi_value` to be checked.
+- `[out] result`: Boolean value that is set to true if `napi_value` represents
+an error, false otherwise.
+
+Returns `napi_ok` if the API succeeded.
+
+This API queries a `napi_value` to check if it represents an error object.
+
+
+#### napi_create_error
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NODE_EXTERN napi_status napi_create_error(napi_env env, const char* msg);
+```
+- `[in] env`: The environment that the API is invoked under.
+- `[in] msg`: C string representing the text to be associated with.
+- `[out] result`: `napi_value` representing the error created.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns a JavaScript Error with the text provided.
+
+#### napi_create_type_error
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NODE_EXTERN napi_status napi_create_type_error(napi_env env, const char* msg);
+```
+- `[in] env`: The environment that the API is invoked under.
+- `[in] msg`: C string representing the text to be associated with.
+- `[out] result`: `napi_value` representing the error created.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns a JavaScript TypeError with the text provided.
+
+
+#### napi_create_range_error
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NODE_EXTERN napi_status napi_create_range_error(napi_env env, const char* msg);
+```
+- `[in] env`: The environment that the API is invoked under.
+- `[in] msg`: C string representing the text to be associated with.
+- `[out] result`: `napi_value` representing the error created.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns a JavaScript RangeError with the text provided.
+
+
+#### napi_get_and_clear_last_exception
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NAPI_EXTERN napi_status napi_get_and_clear_last_exception(napi_env env,
+                                                          napi_value* result);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[out] result`: The exception if one is pending, NULL otherwise.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns true if an exception is pending.
+
+#### napi_is_exception_pending
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NAPI_EXTERN napi_status napi_is_exception_pending(napi_env env, bool* result);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[out] result`: Boolean value that is set to true if an exception is pending.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns true if an exception is pending.
+
+
+## Object Lifetime management
+
+As N-API calls are made, handles to objects in the heap for the underlying
+VM may be returned as `napi_values`. These handles must hold the
+objects 'live' until they are no longer required by the native code,
+otherwise the objects could be collected before the native code was
+finished using them.
+
+As object handles are returned they are associated with a
+'scope'. The lifespan for the default scope is tied to the lifespan
+of the native method call. The result is that, by default, handles
+remain valid and the objects associated with these handles will be
+held live for the lifespan of the native method call.
+
+In many cases, however, it is necessary that the handles remain valid for
+either a shorter or longer lifespan than that of the native method.
+The sections which follow describe the N-API functions than can be used
+to change the handle lifespan from the default.
+
+### Making handle lifespan shorter than that of the native method
+It is often necessary to make the lifespan of handles shorter than
+the lifespan of a native method. For example, consider a native method
+that has a loop which iterates through the elements in a large array:
+
+```C
+for (int i = 0; i < 1000000; i++) {
+  napi_value result;
+  napi_status status = napi_get_element(e object, i, &result);
+  if (status != napi_ok) {
+    break;
+  }
+  // do something with element
+}
+```
+
+This would result in a large number of handles being created, consuming
+substantial resources. In addition, even though the native code could only
+use the most recent handle, all of the associated objects would also be
+kept alive since they all share the same scope.
+
+To handle this case, N-API provides the ability to establish a new 'scope' to
+which newly created handles will be associated. Once those handles
+are no longer required, the scope can be 'closed' and any handles associated
+with the scope are invalidated. The methods available to open/close scopes are
+[`napi_open_handle_scope`][] and [`napi_close_handle_scope`][].
+
+N-API only supports a single nested hiearchy of scopes. There is only one
+active scope at any time, and all new handles will be associated with that
+scope while it is active. Scopes must be closed in the reverse order from
+which they are opened. In addition, all scopes created within a native method
+must be closed before returning from that method.
+
+Taking the earlier example, adding calls to [`napi_open_handle_scope`][] and
+[`napi_close_handle_scope`][] would ensure that at most a single handle
+is valid throughout the execution of the loop:
+
+```C
+for (int i = 0; i < 1000000; i++) {napi_
+  napi_handle_scope scope;
+  napi_status status = napi_open_handle_scope(env, &scope);
+  if (status != napi_ok) {
+    break;
+  }
+  napi_value result;
+  status = napi_get_element(e object, i, &result);
+  if (status != napi_ok) {
+    break;
+  }
+  // do something with element
+  status = napi_close_handle_scope(env, scope);
+  if (status != napi_ok) {
+    break;
+  }
+}
+```
+
+When nesting scopes, there are cases where a handle from an
+inner scope needs  to live beyond the lifespan of that scope. N-API supports an
+'escapable scope' in order to support this case. An escapable scope
+allows one or more handles to be 'promoted' so that they 'escape' the
+current scope and the lifespan of the handle(s) changes from the current
+scope to that of the outer scope.
+
+The methods available to open/close escapable scopes are
+[`napi_open_escapable_handle_scope`][] and [`napi_close_escapable_handle_scope`][].
+
+The request to promote a handle is made through the [`napi_escape_handle`][].
+
+#### napi_open_handle_scope
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NODE_EXTERN napi_status napi_open_handle_scope(napi_env env,
+                                               napi_handle_scope* result);
+```
+- `[in] env`: The environment that the API is invoked under.
+- `[out] result`: `napi_value` representing the new scope.
+
+Returns `napi_ok` if the API succeeded.
+
+This API open a new scope.
+
+#### napi_close_handle_scope
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NODE_EXTERN napi_status napi_close_handle_scope(napi_env env,
+                                                napi_handle_scope scope);
+```
+- `[in] env`: The environment that the API is invoked under.
+- `[in] scope`: `napi_value` representing the scope to be closed.
+
+Returns `napi_ok` if the API succeeded.
+
+This API closes the scope passed in. Scopes must be closed in the
+reverse order from which they were created.
+
+#### napi_open_escapable_handle_scope
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NODE_EXTERN napi_status
+    napi_open_escapable_handle_scope(napi_env env,
+                                     napi_handle_scope* result);
+```
+- `[in] env`: The environment that the API is invoked under.
+- `[out] result`: `napi_value` representing the new scope.
+
+Returns `napi_ok` if the API succeeded.
+
+This API open a new scope from which objects can be promoted
+to the outer scope.
+
+#### napi_close_escapable_handle_scope
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NODE_EXTERN napi_status
+    napi_close_escapable_handle_scope(napi_env env,
+                                      napi_handle_scope scope);
+```
+- `[in] env`: The environment that the API is invoked under.
+- `[in] scope`: `napi_value` representing the scope to be closed.
+
+Returns `napi_ok` if the API succeeded.
+
+This API closes the scope passed in. Scopes must be closed in the
+reverse order from which they were created.
+
+#### napi_escape_handle
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NAPI_EXTERN napi_status napi_escape_handle(napi_env env,
+                                           napi_escapable_handle_scope scope,
+                                           napi_value escapee,
+                                           napi_value* result);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] scope`: `napi_value` representing the current scope.
+- `[in] escapee`: `napi_value` representing the JavaScript Object to be escaped.
+- `[out] result`: `napi_value` representing the handle to the escaped
+Object in the outer scope.
+
+Returns `napi_ok` if the API succeeded.
+
+This API promotes the handle to the JavaScript object so that it valid
+for the lifetime of the outer scope.
+
+
+### References to objects with a lifespan longer than that of the native method
+In some cases an addon will need to be able to create and reference objects
+with a lifespan longer than that of a single native method invocation. For
+example, to create a constructor and later use that constructor
+in a request to creates instances, it must be possible to reference
+the constructor object across many different instance creation requests. This
+would not be possible with a normal handle returned as a `napi_value` as
+described in the earlier section. The lifespan of a normal handle is
+managed by scopes and all scopes must be closed before the end of a native
+method.
+
+N-API provides methods to create persistent references to an object.
+Each persistent reference has an associated count with a value of 0
+or higher. The count determines if the reference will keep
+the corresponding object live. References with a count of 0 do not
+prevent the object from being collected and are often called 'weak'
+references. Any count greater than 0 will prevent the object
+from being collected.
+
+References can be created with an initial reference count. The count can
+then be modified through [`napi_reference_ref`][] and
+[`napi_reference_unref`][]. If an object is collected while the count
+for a reference is 0, all subsequent calls to
+get the object associated with the reference [`napi_get_reference_value`][]
+will return NULL for the returned `napi_value`. An attempt to call
+[`napi_reference_ref`][] for a reference whose object has been collected
+will result in an error.
+
+References must be deleted once they are no longer required by the addon. When
+a reference is deleted it will no longer prevent the corresponding object from
+being collected. Failure to delete a persistent reference will result in
+a 'memory leak' with both the native memory for the persistent reference and
+the corresponding object on the heap being retained forever.
+
+There can be multiple persistent references created which refer to the same
+object, each of which will either keep the object live or not based on its
+individual count.
+
+#### napi_create_reference
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NODE_EXTERN napi_status napi_create_reference(napi_env env,
+                                              napi_value value,
+                                              int initial_refcount,
+                                              ndapi_ref* result);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: `napi_value` representing the Object to which we want
+a reference to.
+- `[in] initial_refcount`: Initial reference count for the new reference.
+- `[out] result`: `napi_ref` pointing to the new reference.
+
+Returns `napi_ok` if the API succeeded.
+
+This API create a new reference with the specified reference count
+to the Object passed in.
+
+#### napi_delete_reference
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NODE_EXTERN napi_status napi_delete_reference(napi_env env, napi_ref ref);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] ref`: `napi_ref` to be deleted.
+
+Returns `napi_ok` if the API succeeded.
+
+This API deletes the reference passed in.
+
+#### napi_reference_ref
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NODE_EXTERN napi_status napi_reference_ref(napi_env env,
+                                           napi_ref ref,
+                                           int* result);
+```
+- `[in] env`: The environment that the API is invoked under.
+- `[in] ref`: `napi_ref` for which the reference count will be incremented.
+- `[out] result`: The new reference count.
+
+Returns `napi_ok` if the API succeeded.
+
+This API increments the reference count for the reference
+passed in and returns the resulting reference count.
+
+
+#### napi_reference_unref
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NODE_EXTERN napi_status napi_reference_unref(napi_env env,
+                                             napi_ref ref,
+                                             int* result);
+```
+- `[in] env`: The environment that the API is invoked under.
+- `[in] ref`: `napi_ref` for which the reference count will be decremented.
+- `[out] result`: The new reference count.
+
+Returns `napi_ok` if the API succeeded.
+
+This API decrements the reference count for the reference
+passed in and returns the resulting reference count.
+
+
+#### napi_get_reference_value
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NODE_EXTERN napi_status napi_get_reference_value(napi_env env,
+                                                 napi_ref ref,
+                                                 napi_value* result);
+```
+
+the `napi_value passed` in or out of these methods is a handle to the
+object to which the reference is related.
+- `[in] env`: The environment that the API is invoked under.
+- `[in] ref`: `napi_ref` for which we requesting the corresponding Object.
+- `[out] result`: The `napi_value` for the Object referenced by the
+`napi_ref`.
+
+Returns `napi_ok` if the API succeeded.
+
+If still valid, this API returns the `napi_value` representing the
+JavaScript Object associated with the `napi_ref`. Otherise, result
+will be NULL.
+
+## Module registration
+N-API modules are registered in the same manner as other modules
+except that instead of using the `NODE_MODULE` macro the following
+is used:
+
+```C
+NAPI_MODULE(addon, Init)
+```
+
+The next difference is the signature for the `Init` method. For a N-API
+module it is as follows:
+
+```C
+void Init(napi_env env, napi_value exports, napi_value module, void* priv);
+```
+
+As with any other module, functions are exported by either adding them to
+the `exports` or `module` objects passed to the `Init` method.
+
+For example, to add the method `hello` as a function so that it can be called
+as a method provided by the addon:
+
+```C
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+  napi_property_descriptor desc =
+    {"hello", Method, 0, 0, 0, napi_default, 0};
+  status = napi_define_properties(env, exports, 1, &desc);
+}
+```
+
+For example, to set a function to be returned by the `require()` for the addon:
+
+```C
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+  napi_property_descriptor desc =
+    {"exports", Method, 0, 0, 0, napi_default, 0};
+  status = napi_define_properties(env, module, 1, &desc);
+}
+```
+
+For example, to define a class so that new instances can be created
+(often used with [Object Wrap][]):
+
+```C
+// NOTE: partial example, not all referenced code is included
+
+napi_status status;
+napi_property_descriptor properties[] = {
+    { "value", nullptr, GetValue, SetValue, 0, napi_default, 0 },
+    DECLARE_NAPI_METHOD("plusOne", PlusOne),
+    DECLARE_NAPI_METHOD("multiply", Multiply),
+};
+
+napi_value cons;
+status =
+    napi_define_class(env, "MyObject", New, nullptr, 3, properties, &cons);
+if (status != napi_ok) return;
+
+status = napi_create_reference(env, cons, 1, &constructor);
+if (status != napi_ok) return;
+
+status = napi_set_named_property(env, exports, "MyObject", cons);
+if (status != napi_ok) return;
+```
+
+For more details on setting properties on either the `exports` or `module`
+objects, see the section on
+[Working with JavaScript Properties][].
+
+For more details on building addon modules in general, refer to the existing API
+
+## Working with JavaScript Values
+N-API exposes a set of APIs to create all types of JavaScript values.
+Some of these types are documented under
+[Section 6](https://tc39.github.io/ecma262/#sec-ecmascript-data-types-and-values)
+of the [ECMAScript Language Specification][].
+
+Fundamentally, these APIs are used to do one of the following:
+1. Create a new JavaScript object
+2. Convert from a primitive C type to an N-API value
+3. Convert from N-API value to a primitive C type
+4. Get global instances including `undefined` and `null`
+
+N-API values are represented by the type `napi_value`.
+Any N-API call that requires a JavaScript value takes in a `napi_value`.
+In some cases, the API does check the type of the `napi_value` up-front.
+However, for better performance, it's better for the caller to make sure that
+the `napi_value` in question is of the JavaScript type expected by the API.
+
+### Enum types
+#### *napi_valuetype*
+```C
+typedef enum {
+  // ES6 types (corresponds to typeof)
+  napi_undefined,
+  napi_null,
+  napi_boolean,
+  napi_number,
+  napi_string,
+  napi_symbol,
+  napi_object,
+  napi_function,
+  napi_external,
+} napi_valuetype;
+```
+
+Describes the type of a `napi_value`. This generally corresponds to the types
+described in
+[Section 6.1](https://tc39.github.io/ecma262/#sec-ecmascript-language-types) of
+the ECMAScript Language Specification.
+In addition to types in that section, `napi_valuetype` can also represent
+Functions and Objects with external data.
+
+#### *napi_typedarray_type*
+```C
+typedef enum {
+  napi_int8_array,
+  napi_uint8_array,
+  napi_uint8_clamped_array,
+  napi_int16_array,
+  napi_uint16_array,
+  napi_int32_array,
+  napi_uint32_array,
+  napi_float32_array,
+  napi_float64_array,
+} napi_typedarray_type;
+```
+
+This represents the underlying binary scalar datatype of the TypedArray.
+Elements of this enum correspond to
+[Section 22.2](https://tc39.github.io/ecma262/#sec-typedarray-objects)
+of the [ECMAScript Language Specification][].
+
+### Object Creation Functions
+#### *napi_create_array*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_create_array(napi_env env, napi_value* result)
+```
+
+- `[in] env`: The environment that the N-API call is invoked under.
+- `[out] result`: A `napi_value` representing a JavaScript Array.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns an N-API value corresponding to a JavaScript Array type.
+JavaScript arrays are described in
+[Section 22.1](https://tc39.github.io/ecma262/#sec-array-objects) of the
+ECMAScript Language Specification.
+
+#### *napi_create_array_with_length*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_create_array_with_length(napi_env env,
+                                          size_t length,
+                                          napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] length`: The initial length of the Array.
+- `[out] result`: A `napi_value` representing a JavaScript Array.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns an N-API value corresponding to a JavaScript Array type.
+The Array's length property is set to the passed-in length parameter.
+However, the underlying buffer is not guaranteed to be pre-allocated by the VM
+when the array is created - that behavior is left to the underlying VM
+implementation.
+if the buffer must be a contiguous block of memory that can be
+directly read and/or written via C, consider using
+[`napi_create_external_arraybuffer`][].
+
+JavaScript arrays are described in
+[Section 22.1](https://tc39.github.io/ecma262/#sec-array-objects) of the
+ECMAScript Language Specification.
+
+#### *napi_create_arraybuffer*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_create_arraybuffer(napi_env env,
+                                    size_t byte_length,
+                                    void** data,
+                                    napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] length`: The length in bytes of the array buffer to create.
+- `[out] data`: Pointer to the underlying byte buffer of the ArrayBuffer.
+- `[out] result`: A `napi_value` representing a JavaScript ArrayBuffer.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns an N-API value corresponding to a JavaScript ArrayBuffer.
+ArrayBuffers are used to represent fixed-length binary data buffers. They are
+normally used as a backing-buffer for TypedArray objects.
+The ArrayBuffer allocated will have an underlying byte buffer whose size is
+determined by the `length` parameter that's passed in.
+The underlying buffer is optionally returned back to the caller in case the
+caller wants to directly manipulate the buffer. This buffer can only be
+written to directly from native code. To write to this buffer from JavaScript,
+a typed array or DataView object would need to be created.
+
+JavaScript ArrayBuffer objects are described in
+[Section 24.1](https://tc39.github.io/ecma262/#sec-arraybuffer-objects)
+of the ECMAScript Language Specification.
+
+#### *napi_create_buffer*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_create_buffer(napi_env env,
+                               size_t size,
+                               void** data,
+                               napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] size`: Size in bytes of the underlying buffer.
+- `[out] data`: Raw pointer to the underlying buffer.
+- `[out] result`: A `napi_value` representing a `node::Buffer`.
+
+Returns `napi_ok` if the API succeeded.
+
+This API allocates a `node::Buffer` object. While this is still a
+fully-supported data structure, in most cases using a TypedArray will suffice.
+
+#### *napi_create_buffer_copy*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_create_buffer_copy(napi_env env,
+                                    size_t length,
+                                    const void* data,
+                                    void** result_data,
+                                    napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] size`: Size in bytes of the input buffer (should be the same as the
+ size of the new buffer).
+- `[in] data`: Raw pointer to the underlying buffer to copy from.
+- `[out] result_data`: Pointer to the new Buffer's underlying data buffer.
+- `[out] result`: A `napi_value` representing a `node::Buffer`.
+
+Returns `napi_ok` if the API succeeded.
+
+This API allocates a `node::Buffer` object and initializes it with data copied
+from the passed-in buffer. While this is still a fully-supported data
+structure, in most cases using a TypedArray will suffice.
+
+#### *napi_create_external*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_create_external(napi_env env,
+                                 void* data,
+                                 napi_finalize finalize_cb,
+                                 void* finalize_hint,
+                                 napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] data`: Raw pointer to the external data being wrapped.
+- `[in] finalize_cb`: Optional callback to call when the wrapped object
+is being collected.
+- `[in] finalize_hint`: Optional hint to pass to the finalize callback
+during collection.
+- `[out] result`: A `napi_value` representing an external object.
+
+Returns `napi_ok` if the API succeeded.
+
+This API allocates a JavaScript object with external data attached to it.
+This is used to wrap native objects and project them into JavaScript.
+The API allows the caller to pass in a finalize callback, in case the
+underlying native resource needs to be cleaned up when the wrapper
+JavaScript object gets collected.
+
+#### napi_create_external_arraybuffer
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status
+napi_create_external_arraybuffer(napi_env env,
+                                 void* external_data,
+                                 size_t byte_length,
+                                 napi_finalize finalize_cb,
+                                 void* finalize_hint,
+                                 napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] external_data`: Pointer to the underlying byte buffer of the
+ArrayBuffer.
+- `[in] byte_length`: The length in bytes of the underlying buffer.
+- `[in] finalize_cb`: Optional callback to call when the ArrayBuffer is
+being collected.
+- `[in] finalize_hint`: Optional hint to pass to the finalize callback
+during collection.
+- `[out] result`: A `napi_value` representing a JavaScript ArrayBuffer.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns an N-API value corresponding to a JavaScript ArrayBuffer.
+The underlying byte buffer of the ArrayBuffer is externally allocated and
+managed. The caller must ensure that the byte buffer remains valid until the
+finalize callback is called.
+
+JavaScript ArrayBuffers are described in
+[Section 24.1](https://tc39.github.io/ecma262/#sec-arraybuffer-objects)
+of the ECMAScript Language Specification.
+
+#### *napi_create_external_buffer*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_create_external_buffer(napi_env env,
+                                        size_t length,
+                                        void* data,
+                                        napi_finalize finalize_cb,
+                                        void* finalize_hint,
+                                        napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] length`: Size in bytes of the input buffer (should be the same as
+the size of the new buffer).
+- `[in] data`: Raw pointer to the underlying buffer to copy from.
+- `[in] finalize_cb`: Optional callback to call when the ArrayBuffer is
+being collected.
+- `[in] finalize_hint`: Optional hint to pass to the finalize callback
+during collection.
+- `[out] result`: A `napi_value` representing a `node::Buffer`.
+
+Returns `napi_ok` if the API succeeded.
+
+This API allocates a `node::Buffer` object and initializes it with data
+backed by the passed in buffer. While this is still a fully-supported data
+structure, in most cases using a TypedArray will suffice.
+
+**Note:** For Node.js >=4 `Buffers` are Uint8Arrays.
+
+#### *napi_create_function*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_create_function(napi_env env,
+                                 const char* utf8name,
+                                 napi_callback cb,
+                                 void* data,
+                                 napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] utf8name`: A string representing the name of the function encoded as
+UTF8.
+- `[in] cb`: A function pointer to the native function to be invoked when the
+created function is invoked from JavaScript.
+- `[in] data`: Optional arbitrary context data to be passed into the native
+function when it is invoked.
+- `[out] result`: A `napi_value` representing a JavaScript function.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns an N-API value corresponding to a JavaScript Function object.
+It's used to wrap native functions so that they can be invoked from JavaScript.
+
+JavaScript Functions are described in
+[Section 19.2](https://tc39.github.io/ecma262/#sec-function-objects)
+of the ECMAScript Language Specification.
+
+#### *napi_create_object*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_create_object(napi_env env, napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[out] result`: A `napi_value` representing a JavaScript Object.
+
+Returns `napi_ok` if the API succeeded.
+
+This API allocates a default JavaScript Object.
+It is the equivalent of doing `new Object()` in JavaScript.
+
+The JavaScript Object type is described in
+[Section 6.1.7](https://tc39.github.io/ecma262/#sec-object-type) of the
+ECMAScript Language Specification.
+
+#### *napi_create_symbol*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_create_symbol(napi_env env,
+                               const char* description,
+                               napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] description`: Null-terminated character buffer representing a
+UTF8-encoded string to describe the symbol.
+- `[out] result`: A `napi_value` representing a JavaScript Symbol.
+
+Returns `napi_ok` if the API succeeded.
+
+This API creates a JavaScript Symbol object from a UTF8-encoded C string
+
+The JavaScript Symbol type is described in
+[Section 19.4](https://tc39.github.io/ecma262/#sec-symbol-objects)
+of the ECMAScript Language Specification.
+
+#### *napi_create_typedarray*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_create_typedarray(napi_env env,
+                                   napi_typedarray_type type,
+                                   size_t length,
+                                   napi_value arraybuffer,
+                                   size_t byte_offset,
+                                   napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] type`: Scalar datatype of the elements within the TypedArray.
+- `[in] length`: Number of elements in the TypedArray.
+- `[in] arraybuffer`: ArrayBuffer underlying the typed array.
+- `[in] byte_offset`: The byte offset within the ArrayBuffer from which to
+start projecting the TypedArray.
+- `[out] result`: A `napi_value` representing a JavaScript TypedArray.
+
+Returns `napi_ok` if the API succeeded.
+
+This API creates a JavaScript TypedArray object over an existing ArrayBuffer.
+TypedArray objects provide an array-like view over an underlying data buffer
+where each element has the same underlying binary scalar datatype.
+
+It's required that (length * size_of_element) + byte_offset should
+be <= the size in bytes of the array passed in. If not, a RangeError exception is
+raised.
+
+JavaScript TypedArray Objects are described in
+[Section 22.2](https://tc39.github.io/ecma262/#sec-typedarray-objects)
+of the ECMAScript Language Specification.
+
+### Functions to convert from C types to N-API
+#### *napi_create_number*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_create_number(napi_env env, double value, napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: Double-precision value to be represented in JavaScript.
+- `[out] result`: A `napi_value` representing a JavaScript Number.
+
+Returns `napi_ok` if the API succeeded.
+
+This API is used to convert from the C double type to the JavaScript
+Number type.
+
+The JavaScript Number type is described in
+[Section 6.1.6](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type)
+of the ECMAScript Language Specification.
+
+#### *napi_create_string_utf16*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_create_string_utf16(napi_env env,
+                                     const char16_t* str,
+                                     size_t length,
+                                     napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] str`: Character buffer representing a UTF16-LE-encoded string.
+- `[in] length`: The length of the string in characters, or -1 if it is
+null-terminated.
+- `[out] result`: A `napi_value` representing a JavaScript String.
+
+Returns `napi_ok` if the API succeeded.
+
+This API creates a JavaScript String object from a UTF16-LE-encoded C string
+
+The JavaScript String type is described in
+[Section 6.1.4](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type)
+of the ECMAScript Language Specification.
+
+#### *napi_create_string_utf8*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_create_string_utf8(napi_env env,
+                                    const char* str,
+                                    size_t length,
+                                    napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] s`: Character buffer representing a UTF8-encoded string.
+- `[in] length`: The length of the string in characters, or -1 if it is
+null-terminated.
+- `[out] result`: A `napi_value` representing a JavaScript String.
+
+Returns `napi_ok` if the API succeeded.
+
+This API creates a JavaScript String object from a UTF8-encoded C string
+
+The JavaScript String type is described in
+[Section 6.1.4](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type)
+of the ECMAScript Language Specification.
+
+### Functions to convert from N-API to C types
+#### *napi_get_array_length*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_array_length(napi_env env,
+                                  napi_value value,
+                                  uint32_t* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: `napi_value` representing the JavaScript Array whose length is
+being queried.
+- `[out] result`: `uint32` representing length of the array.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns the length of an array.
+
+Array length is described in
+[Section 22.1.4.1](https://tc39.github.io/ecma262/#sec-properties-of-array-instances-length)
+of the ECMAScript Language Specification.
+
+#### *napi_get_arraybuffer_info*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_arraybuffer_info(napi_env env,
+                                      napi_value arraybuffer,
+                                      void** data,
+                                      size_t* byte_length)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] arraybuffer`: `napi_value` representing the ArrayBuffer being queried.
+- `[out] data`: The underlying data buffer of the ArrayBuffer.
+- `[out] byte_length`: Length in bytes of the underlying data buffer.
+
+Returns `napi_ok` if the API succeeded.
+
+This API is used to retrieve the underlying data buffer of an ArrayBuffer and
+its length.
+WARNING: Use caution while using this API. The lifetime of the underlying data
+buffer is managed by the ArrayBuffer even after it's returned. A
+possible safe way to use this API is in conjunction with [`napi_create_reference`][],
+which can be used to guarantee control over the lifetime of the
+ArrayBuffer. It's also safe to use the returned data buffer within the same
+callback as long as there are no calls to other APIs that might trigger a GC.
+
+#### *napi_get_buffer_info*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_buffer_info(napi_env env,
+                                 napi_value value,
+                                 void** data,
+                                 size_t* length)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: `napi_value` representing the `node::Buffer` being queried.
+- `[out] data`: The underlying data buffer of the `node::Buffer`.
+- `[out] length`: Length in bytes of the underlying data buffer.
+
+Returns `napi_ok` if the API succeeded.
+
+This API is used to retrieve the underlying data buffer of a `node::Buffer`
+and it's length.
+Warning: Use caution while using this API since the underlying data buffer's
+lifetime is not guaranteed if it's managed by the VM.
+
+#### *napi_get_prototype*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_prototype(napi_env env,
+                               napi_value object,
+                               napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] object`: `napi_value` representing JavaScript Object whose prototype
+to return. This returns the equivalent of `Object.getPrototypeOf` (which is
+not the same as the function's `prototype` property).
+- `[out] result`: `napi_value` representing prototype of the given object.
+
+Returns `napi_ok` if the API succeeded.
+
+#### *napi_get_typedarray_info*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_typedarray_info(napi_env env,
+                                     napi_value typedarray,
+                                     napi_typedarray_type* type,
+                                     size_t* length,
+                                     void** data,
+                                     napi_value* arraybuffer,
+                                     size_t* byte_offset)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] typedarray`: `napi_value` representing the TypedArray whose
+properties to query.
+- `[out] type`: Scalar datatype of the elements within the TypedArray.
+- `[out] length`: Number of elements in the TypedArray.
+- `[out] data`: The data buffer underlying the typed array.
+- `[out] byte_offset`: The byte offset within the data buffer from which
+to start projecting the TypedArray.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns various properties of a typed array.
+Warning: Use caution while using this API since the underlying data buffer
+is managed by the VM
+
+#### *napi_get_value_bool*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_value_bool(napi_env env, napi_value value, bool* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: `napi_value` representing JavaScript Boolean.
+- `[out] result`: C boolean primitive equivalent of the given JavaScript
+Boolean.
+
+Returns `napi_ok` if the API succeeded. If a non-boolean `napi_value` is
+passed in it returns `napi_boolean_expected`.
+
+This API returns C boolean primitive equivalent of the given JavaScript
+Boolea
+
+#### *napi_get_value_double*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_value_double(napi_env env,
+                                  napi_value value,
+                                  double* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: `napi_value` representing JavaScript Number.
+- `[out] result`: C double primitive equivalent of the given JavaScript
+Number.
+
+Returns `napi_ok` if the API succeeded. If a non-number `napi_value` is passed
+in it returns `napi_number_expected`.
+
+This API returns the C double primitive equivalent of the given JavaScript
+Number.
+
+
+#### *napi_get_value_external*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_value_external(napi_env env,
+                                    napi_value value,
+                                    void** result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: `napi_value` representing JavaScript External value.
+- `[out] result`: Pointer to the data wrapped by the JavaScript External value.
+
+Returns `napi_ok` if the API succeeded. If a non-external `napi_value` is
+passed in it returns `napi_invalid_arg`.
+
+This API returns the pointer to the data wrapped by the JavaScript
+External value
+
+#### *napi_get_value_int32*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_value_int32(napi_env env,
+                                 napi_value value,
+                                 int32_t* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: `napi_value` representing JavaScript Number.
+- `[out] result`: C int32 primitive equivalent of the given JavaScript Number.
+
+Returns `napi_ok` if the API succeeded. If a non-number `napi_value`
+is passed in `napi_number_expected .
+
+This API returns the C int32 primitive equivalent
+of the given JavaScript Number. If the number exceeds the range of the
+32 bit integer, then the result is truncated to the equivalent of the
+bottom 32 bits. This can result in a large positive number becoming
+a negative number if the the value is > 2^31 -1.
+
+#### *napi_get_value_int64*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_value_int64(napi_env env,
+                                 napi_value value,
+                                 int64_t* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: `napi_value` representing JavaScript Number.
+- `[out] result`: C int64 primitive equivalent of the given JavaScript Number.
+
+Returns `napi_ok` if the API succeeded. If a non-number `napi_value`
+is passed in it returns `napi_number_expected`.
+
+This API returns the C int64 primitive equivalent of the given
+JavaScript Number
+
+#### *napi_get_value_string_length*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_value_string_length(napi_env env,
+                                         napi_value value,
+                                         int* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: `napi_value` representing JavaScript string.
+- `[out] result`: Number of characters in the given JavaScript string.
+
+Returns `napi_ok` if the API succeeded. If a non-String `napi_value`
+is passed in it returns `napi_string_expected`.
+
+This API returns the number of characters in the given JavaScript string.
+
+#### *napi_get_value_string_utf8*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_value_string_utf8(napi_env env,
+                                       napi_value value,
+                                       char* buf,
+                                       size_t bufsize,
+                                       size_t* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: `napi_value` representing JavaScript string.
+- `[in] buf`: Buffer to write the UTF8-encoded string into. If NULL is passed
+ in, the length of the string (in bytes) is returned.
+- `[in] bufsize`: Size of the destination buffer.
+- `[out] result`: Number of bytes copied into the buffer including the null.
+terminator. If the buffer size is insufficient, the string will be truncated
+including a null terminator.
+
+Returns `napi_ok` if the API succeeded. Ifa non-String `napi_value`
+x is passed in it returns `napi_string_expected`.
+
+This API returns the UTF8-encoded string corresponding the value passed in.
+
+#### *napi_get_value_string_utf16_length*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_value_string_utf16(napi_env env,
+                                        napi_value value,
+                                        char16_t* buf,
+                                        size_t bufsize,
+                                        size_t* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: `napi_value` representing JavaScript string.
+- `[in] buf`: Buffer to write the UTF16-LE-encoded string into. If NULL is
+passed in, the length of the string (in 2-byte code units) is returned.
+- `[in] bufsize`: Size of the destination buffer.
+- `[out] result`: Number of 2-byte code units copied into the buffer including
+the null terminateor. If the buffer size is insufficient, the string will be
+truncated including a null terminator.
+
+Returns `napi_ok` if the API succeeded. If a non-String `napi_value`
+is passed in it returns `napi_string_expected`.
+
+This API returns the UTF16-encoded string corresponding the value passed in.
+
+#### *napi_get_value_uint32*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_value_uint32(napi_env env,
+                                  napi_value value,
+                                  uint32_t* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: `napi_value` representing JavaScript Number.
+- `[out] result`: C primitive equivalent of the given `napi_value` as a
+`uint32_t`.
+
+Returns `napi_ok` if the API succeeded. If a non-number `napi_value`
+is passed in it returns `napi_number_expected`.
+
+This API returns the C primitive equivalent of the given `napi_value` as a
+`uint32_t`.
+
+### Functions to get global instances
+#### *napi_get_boolean*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_boolean(napi_env env, bool value, napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: The value of the boolean to retrieve.
+- `[out] result`: `napi_value` representing JavaScript Boolean singleton to
+retrieve.
+
+Returns `napi_ok` if the API succeeded.
+
+This API is used to return the JavaScript singleton object that is used to
+represent the given boolean value
+
+#### *napi_get_global*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_global(napi_env env, napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[out] result`: `napi_value` representing JavaScript Global Object.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns the global Object.
+
+#### *napi_get_null*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_null(napi_env env, napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[out] result`: `napi_value` representing JavaScript Null Object.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns the null Object.
+
+#### *napi_get_undefined*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_undefined(napi_env env, napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[out] result`: `napi_value` representing JavaScript Undefined value.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns the Undefined object.
+
+## Working with JavaScript Values - Abstract Operations
+
+N-API exposes a set of APIs to perform some abstract operations on JavaScript
+values. Some of these operations are documented under
+[Section 7](https://tc39.github.io/ecma262/#sec-abstract-operations)
+of the [ECMAScript Language Specification](https://tc39.github.io/ecma262/).
+
+These APIs support doing one of the following:
+1. Coerce JavaScript values to specific JavaScript types (such as Number or
+   String)
+2. Check the type of a JavaScript value
+3. Check for equality between two JavaScript values
+
+### *napi_coerce_to_bool*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_coerce_to_bool(napi_env env,
+                                napi_value value,
+                                napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: The JavaScript value to coerce.
+- `[out] result`: `napi_value` representing the coerced JavaScript Boolean.
+
+Returns `napi_ok` if the API succeeded.
+
+This API implements the abstract operation ToBoolean as defined in
+[Section 7.1.2](https://tc39.github.io/ecma262/#sec-toboolean)
+of the ECMAScript Language Specification.
+This API can be re-entrant if getters are defined on the passed-in Object.
+
+### *napi_coerce_to_number*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_coerce_to_number(napi_env env,
+                                  napi_value value,
+                                  napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: The JavaScript value to coerce.
+- `[out] result`: `napi_value` representing the coerced JavaScript Number.
+
+Returns `napi_ok` if the API succeeded.
+
+This API implements the abstract operation ToNumber as defined in
+[Section 7.1.3](https://tc39.github.io/ecma262/#sec-tonumber)
+of the ECMAScript Language Specification.
+This API can be re-entrant if getters are defined on the passed-in Object.
+
+### *napi_coerce_to_object*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_coerce_to_object(napi_env env,
+                                  napi_value value,
+                                  napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: The JavaScript value to coerce.
+- `[out] result`: `napi_value` representing the coerced JavaScript Object.
+
+Returns `napi_ok` if the API succeeded.
+
+This API implements the abstract operation ToObject as defined in
+[Section 7.1.13](https://tc39.github.io/ecma262/#sec-toobject)
+of the ECMAScript Language Specification.
+This API can be re-entrant if getters are defined on the passed-in Object.
+
+### *napi_coerce_to_string*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_coerce_to_string(napi_env env,
+                                  napi_value value,
+                                  napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: The JavaScript value to coerce.
+- `[out] result`: `napi_value` representing the coerced JavaScript String.
+
+Returns `napi_ok` if the API succeeded.
+
+This API implements the abstract operation ToString as defined in
+[Section 7.1.13](https://tc39.github.io/ecma262/#sec-tostring)
+of the ECMAScript Language Specification.
+This API can be re-entrant if getters are defined on the passed-in Object.
+
+### *napi_typeof*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_typeof(napi_env env, napi_value value, napi_valuetype* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: The JavaScript value whose type to query.
+- `[out] result`: The type of the JavaScript value.
+
+Returns `napi_ok` if the API succeeded.
+- `napi_invalid_arg` if the type of `value` is not a known ECMAScript type and
+ `value` is not an External value.
+
+This API represents behavior similar to invoking the `typeof` Operator on
+the object as defined in [Section 12.5.5][] of the ECMAScript Language
+Specification. However, it has support for detecting an External value.
+If `value` has a type that is invalid, an error is returned.
+
+### *napi_instanceof*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_instanceof(napi_env env,
+                            napi_value object,
+                            napi_value constructor,
+                            bool* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] object`: The JavaScript value to check.
+- `[in] constructor`: The JavaScript function object of the constructor
+function to check against.
+- `[out] result`: Boolean that is set to true if `object instanceof constructor`
+is true.
+
+Returns `napi_ok` if the API succeeded.
+
+This API represents invoking the `instanceof` Operator on the object as
+defined in
+[Section 12.10.4](https://tc39.github.io/ecma262/#sec-instanceofoperator)
+of the ECMAScript Language Specification.
+
+### *napi_is_array*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_is_array(napi_env env, napi_value value, bool* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: The JavaScript value to check.
+- `[out] result`: Whether the given object is an array.
+
+Returns `napi_ok` if the API succeeded.
+
+This API represents invoking the `IsArray` operation on the object
+as defined in [Section 7.2.2](https://tc39.github.io/ecma262/#sec-isarray)
+of the ECMAScript Language Specification.
+
+### *napi_is_arraybuffer*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_is_arraybuffer(napi_env env, napi_value value, bool* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: The JavaScript value to check.
+- `[out] result`: Whether the given object is an ArrayBuffer.
+
+Returns `napi_ok` if the API succeeded.
+
+This API checks if the Object passsed in is an array buffer.
+
+### *napi_is_buffer*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_is_buffer(napi_env env, napi_value value, bool* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: The JavaScript value to check.
+- `[out] result`: Whether the given `napi_value` represents a `node::Buffer`
+object.
+
+Returns `napi_ok` if the API succeeded.
+
+This API checks if the Object passsed in is a buffer.
+
+### *napi_is_error*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_is_error(napi_env env, napi_value value, bool* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: The JavaScript value to check.
+- `[out] result`: Whether the given `napi_value` represents an Error object.
+
+Returns `napi_ok` if the API succeeded.
+
+This API checks if the Object passsed in is an Error.
+
+### *napi_is_typedarray*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_is_typedarray(napi_env env, napi_value value, bool* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: The JavaScript value to check.
+- `[out] result`: Whether the given `napi_value` represents a TypedArray.
+
+Returns `napi_ok` if the API succeeded.
+
+This API checks if the Object passsed in is a typed array.
+
+### *napi_strict_equals*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_strict_equals(napi_env env,
+                               napi_value lhs,
+                               napi_value rhs,
+                               bool* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] lhs`: The JavaScript value to check.
+- `[in] rhs`: The JavaScript value to check against.
+- `[out] result`: Whether the two `napi_value` objects are equal.
+
+Returns `napi_ok` if the API succeeded.
+
+This API represents the invocation of the Strict Equality algorithm as
+defined in
+[Section 7.2.14](https://tc39.github.io/ecma262/#sec-strict-equality-comparison)
+of the ECMAScript Language Specification.
+
+## Working with JavaScript Properties
+
+N-API exposes a set of APIs to get and set properties on JavaScript
+objects. Some of these types are documented under
+[Section 7](https://tc39.github.io/ecma262/#sec-operations-on-objects) of the
+[ECMAScript Language Specification](https://tc39.github.io/ecma262/).
+
+Properties in JavaScript are represented as a tuple of a key and a value.
+Fundamentally, all property keys in N-API can be represented in one of the
+following forms:
+- Named: a simple UTF8-encoded string
+- Integer-Indexed: an index value represented by `uint32_t`
+- JavaScript value: these are represented in N-API by `napi_value`. This can
+be a `napi_value` representing a String, Number or Symbol.
+
+N-API values are represented by the type `napi_value`.
+Any N-API call that requires a JavaScript value takes in a `napi_value`.
+However, it's the caller's responsibility to make sure that the
+`napi_value` in question is of the JavaScript type expected by the API.
+
+The APIs documented in this section provide a simple interface to
+get and set properties on arbitrary JavaScript objects represented by
+`napi_value`.
+
+For instance, consider the following JavaScript code snippet:
+```js
+const obj = {};
+obj.myProp = 123;
+```
+The equivalent can be done using N-API values with the following snippet:
+```C
+napi_status status = napi_generic_failure;
+
+// const obj = {}
+napi_value obj, value;
+status = napi_create_object(env, &obj);
+if (status != napi_ok) return status;
+
+// Create a napi_value for 123
+status = napi_create_number(env, 123, &value);
+if (status != napi_ok) return status;
+
+// obj.myProp = 123
+status = napi_set_named_property(env, obj, "myProp", value);
+if (status != napi_ok) return status;
+```
+
+Indexed properties can be set in a similar manner. Consider the following
+JavaScript snippet:
+```js
+const arr = [];
+arr[123] = 'hello';
+```
+The equivalent can be done using N-API values with the following snippet:
+```C
+napi_status status = napi_generic_failure;
+
+// const arr = [];
+napi_value arr, value;
+status = napi_create_array(env, &arr);
+if (status != napi_ok) return status;
+
+// Create a napi_value for 'hello'
+status = napi_create_string_utf8(env, "hello", -1, &value);
+if (status != napi_ok) return status;
+
+// arr[123] = 'hello';
+status = napi_set_element(env, arr, 123, value);
+if (status != napi_ok) return status;
+```
+
+Properties can be retrieved using the APIs described in this section.
+Consider the following JavaScript snippet:
+```js
+const arr = [];
+const value = arr[123];
+```
+
+The following is the approximate equivalent of the N-API counterpart:
+```C
+napi_status status = napi_generic_failure;
+
+// const arr = []
+napi_value arr, value;
+status = napi_create_array(env, &arr);
+if (status != napi_ok) return status;
+
+// const value = arr[123]
+status = napi_get_element(env, arr, 123, &value);
+if (status != napi_ok) return status;
+```
+
+Finally, multiple properties can also be defined on an object for performance
+reasons. Consider the following JavaScript:
+```js
+const obj = {};
+Object.defineProperties(obj, {
+  'foo': { value: 123, writable: true, configurable: true, enumerable: true },
+  'bar': { value: 456, writable: true, configurable: true, enumerable: true }
+});
+```
+
+The following is the approximate equivalent of the N-API counterpart:
+```C
+napi_status status = napi_status_generic_failure;
+
+// const obj = {};
+napi_value obj;
+status = napi_create_obj(env, &obj);
+if (status != napi_ok) return status;
+
+// Create napi_values for 123 and 456
+napi_value fooValue, barValue;
+status = napi_create_number(env, 123, &fooValue);
+if (status != napi_ok) return status;
+status = napi_create_number(env, 456, &barValue);
+if (status != napi_ok) return status;
+
+// Set the properties
+napi_property_descriptors descriptors[] = {
+  { "foo", fooValue, 0, 0, 0, napi_default, 0 },
+  { "bar", barValue, 0, 0, 0, napi_default, 0 }
+}
+status = napi_define_properties(env,
+                                obj,
+                                sizeof(descriptors) / sizeof(descriptors[0]),
+                                descriptors);
+if (status != napi_ok) return status;
+```
+
+### Structures
+#### *napi_property_attributes*
+```C
+typedef enum {
+  napi_default = 0,
+  napi_read_only = 1 << 0,
+  napi_dont_enum = 1 << 1,
+  napi_dont_delete = 1 << 2,
+  napi_static_property = 1 << 10,
+} napi_property_attributes;
+```
+
+`napi_property_attributes` are flags used to control the behavior of properties
+set on a JavaScript object. They roughly correspond to the attributes listed in
+[Section 6.1.7.1](https://tc39.github.io/ecma262/#table-2) of the
+[ECMAScript Language Specification](https://tc39.github.io/ecma262/). They can
+be one or more of the following bitflags:
+
+- `napi_default` - Used to indicate that no explicit attributes are set on the
+given property. By default, a property is Writable, Enumerable, and
+ Configurable. This is a deviation from the ECMAScript specification,
+ where generally the values for a property descriptor attribute default to
+ false if they're not provided.
+- `napi_read_only` - Used to indicate that a given property is not Writable.
+- `napi_dont_enum` - Used to indicate that a given property is not Enumerable.
+- `napi_dont_delete` - Used to indicate that a given property is not.
+Configurable, as defined in
+[Section 6.1.7.1](https://tc39.github.io/ecma262/#table-2) of the
+[ECMAScript Language Specification](https://tc39.github.io/ecma262/).
+- `napi_static_property` - Used to indicate that the property will be defined as
+a static property on a class as opposed to an instance property, which is the
+default. This is used only by [`napi_define_class`][]. It is ignored by
+`napi_define_properties`.
+
+#### *napi_property_descriptor*
+```C
+typedef struct {
+  const char* utf8name;
+
+  napi_callback method;
+  napi_callback getter;
+  napi_callback setter;
+  napi_value value;
+
+  napi_property_attributes attributes;
+  void* data;
+} napi_property_descriptor;
+```
+
+- `utf8name`: String describing the key for the property, encoded as UTF8.
+- `value`: The value that's retrieved by a get access of the property if the
+ property is a data property. If this is passed in, set `getter`, `setter`,
+ `method` and `data` to `NULL` (since these members won't be used).
+- `getter`: A function to call when a get access of the property is performed.
+If this is passed in, set `value` and `method` to `NULL` (since these members
+won't be used). The given function is called implicitly by the runtime when the
+property is accessed from JavaScript code (or if a get on the property is
+performed using a N-API call).
+- `setter`: A function to call when a set access of the property is performed.
+If this is passed in, set `value` and `method` to `NULL` (since these members
+won't be used). The given function is called implicitly by the runtime when the
+property is set from JavaScript code (or if a set on the property is
+performed using a N-API call).
+- `method`: Set this to make the property descriptor object's `value`
+property to be a JavaScript function represented by `method`. If this is
+passed in, set `value`, `getter` and `setter` to `NULL` (since these members
+won't be used).
+- `data`: The callback data passed into `method`, `getter` and `setter` if
+this function is invoked.
+- `attributes`: The attributes associated with the particular property.
+See [`napi_property_attributes`](#napi_property_attributes).
+
+### Functions
+#### *napi_get_property_names*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_property_names(napi_env env,
+                                    napi_value object,
+                                    napi_value* result);
+```
+
+- `[in] env`: The environment that the N-API call is invoked under.
+- `[in] object`: The object from which to retrieve the properties.
+- `[out] result`: A `napi_value` representing an array of JavaScript values
+that represent the property names of the object. The API can be used to
+iterate over `result` using [`napi_get_array_length`][]
+and [`napi_get_element`][].
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns the array of propertys for the Object passed in
+
+#### *napi_set_property*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_set_property(napi_env env,
+                              napi_value object,
+                              napi_value key,
+                              napi_value value);
+```
+
+- `[in] env`: The environment that the N-API call is invoked under.
+- `[in] object`: The object on which to set the property.
+- `[in] key`: The name of the property to set.
+- `[in] value`: The property value.
+
+Returns `napi_ok` if the API succeeded.
+
+This API set a property on the Object passed in.
+
+#### *napi_get_property*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_property(napi_env env,
+                              napi_value object,
+                              napi_value key,
+                              napi_value* result);
+```
+
+- `[in] env`: The environment that the N-API call is invoked under.
+- `[in] object`: The object from which to retrieve the property.
+- `[in] key`: The name of the property to retrieve.
+- `[out] result`: The value of the property.
+
+Returns `napi_ok` if the API succeeded.
+
+This API gets the requested property from the Object passed in.
+
+
+#### *napi_has_property*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_has_property(napi_env env,
+                              napi_value object,
+                              napi_value key,
+                              bool* result);
+```
+
+- `[in] env`: The environment that the N-API call is invoked under.
+- `[in] object`: The object to query.
+- `[in] key`: The name of the property whose existence to check.
+- `[out] result`: Whether the property exists on the object or not.
+
+Returns `napi_ok` if the API succeeded.
+
+This API checks if the Object passed in has the named property.
+
+
+#### *napi_set_named_property*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_set_named_property(napi_env env,
+                                    napi_value object,
+                                    const char* utf8Name,
+                                    napi_value value);
+```
+
+- `[in] env`: The environment that the N-API call is invoked under.
+- `[in] object`: The object on which to set the property.
+- `[in] utf8Name`: The name of the property to set.
+- `[in] value`: The property value.
+
+Returns `napi_ok` if the API succeeded.
+
+This method is equivalent to calling [`napi_set_property`][] with a `napi_value`
+created from the string passed in as `utf8Name`
+
+#### *napi_get_named_property*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_named_property(napi_env env,
+                                    napi_value object,
+                                    const char* utf8Name,
+                                    napi_value* result);
+```
+
+- `[in] env`: The environment that the N-API call is invoked under.
+- `[in] object`: The object from which to retrieve the property.
+- `[in] utf8Name`: The name of the property to get.
+- `[out] result`: The value of the property.
+
+Returns `napi_ok` if the API succeeded.
+
+This method is equivalent to calling [`napi_get_property`][] with a `napi_value`
+created from the string passed in as `utf8Name`
+
+#### *napi_has_named_property*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_has_named_property(napi_env env,
+                                    napi_value object,
+                                    const char* utf8Name,
+                                    bool* result);
+```
+
+- `[in] env`: The environment that the N-API call is invoked under.
+- `[in] object`: The object to query.
+- `[in] utf8Name`: The name of the property whose existence to check.
+- `[out] result`: Whether the property exists on the object or not.
+
+Returns `napi_ok` if the API succeeded.
+
+This method is equivalent to calling [`napi_has_property`][] with a `napi_value`
+created from the string passed in as `utf8Name`
+
+#### *napi_set_element*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_set_element(napi_env env,
+                             napi_value object,
+                             uint32_t index,
+                             napi_value value);
+```
+
+- `[in] env`: The environment that the N-API call is invoked under.
+- `[in] object`: The object from which to set the properties.
+- `[in] index`: The index of the property to set.
+- `[in] value`: The property value.
+
+Returns `napi_ok` if the API succeeded.
+
+This API sets and element on the Object passed in.
+
+#### *napi_get_element*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_element(napi_env env,
+                             napi_value object,
+                             uint32_t index,
+                             napi_value* result);
+```
+
+- `[in] env`: The environment that the N-API call is invoked under.
+- `[in] object`: The object from which to retrieve the property.
+- `[in] index`: The index of the property to get.
+- `[out] result`: The value of the property.
+
+Returns `napi_ok` if the API succeeded.
+
+This API gets the element at the requested index.
+
+#### *napi_has_element*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_has_element(napi_env env,
+                             napi_value object,
+                             uint32_t index,
+                             bool* result);
+```
+
+- `[in] env`: The environment that the N-API call is invoked under.
+- `[in] object`: The object to query.
+- `[in] index`: The index of the property whose existence to check.
+- `[out] result`: Whether the property exists on the object or not.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns if the Object passed in has an element at the
+requested index.
+
+#### *napi_define_properties*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_define_properties(napi_env env,
+                                   napi_value object,
+                                   size_t property_count,
+                                   const napi_property_descriptor* properties);
+```
+
+- `[in] env`: The environment that the N-API call is invoked under.
+- `[in] object`: The object from which to retrieve the properties.
+- `[in] property_count`: The number of elements in the `properties` array.
+- `[in] properties`: The array of property descriptors.
+
+Returns `napi_ok` if the API succeeded.
+
+This method allows the efficient definition of multiple properties on a given
+object. The properties are defined using property descriptors (See
+[`napi_property_descriptor`][]). Given an array of such property descriptors, this
+API will set the properties on the object one at a time, as defined by
+DefineOwnProperty (described in [Section 9.1.6][] of the ECMA262 specification).
+
+## Working with JavaScript Functions
+
+N-API provides a set of APIs that allow JavaScript code to
+call back into native code. N-API APIs that support calling back
+into native code take in a callback functions represented by
+the `napi_callback` type. When the JavaScript VM calls back to
+native code, the `napi_callback` function provided is invoked. The APIs
+documented in this section allow the callback function to do the
+following:
+- Get information about the context in which the callback was invoked.
+- Get the arguments passed into the callback.
+- Return a `napi_value` back from the callback.
+
+Additionally, N-API provides a set of functions which allow calling
+JavaScript functions from native code. One can either call a function
+like a regular JavaScript function call, or as a constructor
+function.
+
+
+### *napi_call_function*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_call_function(napi_env env,
+                               napi_value recv,
+                               napi_value func,
+                               int argc,
+                               const napi_value* argv,
+                               napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] recv`: The `this` object passed to the called function.
+- `[in] func`: `napi_value` representing the JavaScript function
+to be invoked.
+- `[in] argc`: The count of elements in the `argv` array.
+- `[in] argv`: Array of `napi_values` representing JavaScript values passed
+in as arguments to the function.
+- `[out] result`: `napi_value` representing the JavaScript object returned.
+
+Returns `napi_ok` if the API succeeded.
+
+This method allows a JavaScript function object to be called from a native
+add-on. This is an primary mechanism of calling back *from* the add-on's
+native code *into* JavaScript. For special cases like calling into JavaScript
+after an async operation, see [`napi_make_callback`][].
+
+A sample use case might look as follows. Consider the following JavaScript
+snippet:
+```js
+function AddTwo(num) {
+  return num + 2;
+}
+```
+
+Then, the above function can be invoked from a native add-on using the
+following code:
+```C
+// Get the function named "AddTwo" on the global object
+napi_value global, add_two, arg;
+napi_status status = napi_get_global(env, &global);
+if (status != napi_ok) return;
+
+status = napi_get_named_property(env, global, "AddTwo", &add_two);
+if (status != napi_ok) return;
+
+// const arg = 1337
+status = napi_create_number(env, 1337, &arg);
+if (status != napi_ok) return;
+
+napi_value* argv = &arg;
+size_t argc = 1;
+
+// AddTwo(arg);
+napi_value return_val;
+status = napi_call_function(env, global, add_two, argc, argv, &return_val);
+if (status != napi_ok) return;
+
+// Convert the result back to a native type
+int32_t result;
+status = napi_get_value_int32(env, return_val, &result);
+if (status != napi_ok) return;
+```
+
+### *napi_create_function*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_create_function(napi_env env,
+                                 const char* utf8name,
+                                 napi_callback cb,
+                                 void* data,
+                                 napi_value* result);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] utf8Name`: The name of the function encoded as UTF8. This is visible
+within JavaScript as the new function object's `name` property.
+- `[in] cb`: The native function which should be called when this function
+object is invoked.
+- `[in] data`: User-provided data context. This will be passed back into the
+function when invoked later.
+- `[out] result`: `napi_value` representing the JavaScript function object for
+the newly created function.
+
+Returns `napi_ok` if the API succeeded.
+
+This API allows an add-on author to create a function object in native code.
+This is the primary mechanism to allow calling *into* the add-on's native code
+*from* Javascript.
+
+**Note:** The newly created function is not automatically visible from
+script after this call. Instead, a property must be explicitly set on any
+object that is visible to JavaScript, in order for the function to be accessible
+from script.
+
+In order to expose a function as part of the
+add-on's module exports, set the newly created function on the exports
+object. A sample module might look as follows:
+```C
+void SayHello(napi_env env, napi_callback_info info) {
+  printf("Hello\n");
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_status status;
+
+  napi_value fn;
+  status =  napi_create_function(env, NULL, SayHello, NULL, &fn);
+  if (status != napi_ok) return;
+
+  status = napi_set_named_property(env, exports, "sayHello", fn);
+  if (status != napi_ok) return;
+}
+
+NAPI_MODULE(addon, Init)
+```
+
+Given the above code, the add-on can be used from JavaScript as follows:
+```js
+const myaddon = require('./addon');
+myaddon.sayHello();
+```
+
+**Note:**  The string passed to require is not necessarily the name passed into
+`NAPI_MODULE` in the earlier snippet but the name of the target in `binding.gyp`
+responsible for creating the `.node` file.
+
+### *napi_get_cb_info*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_get_cb_info(napi_env env,
+                             napi_callback_info cbinfo,
+                             size_t* argc,
+                             napi_value* argv,
+                             napi_value* thisArg,
+                             void** data)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] cbinfo`: The callback info passed into the callback function.
+- `[in-out] argc`: Specifies the size of the provided `argv` array
+and receives the actual count of arguments.
+- `[out] argv`: Buffer to which the `napi_value` representing the
+arguments are copied. If there are more arguments than the provided
+count, only the requested number of arguments are copied. If there are fewer
+arguments provided than claimed, the rest of `argv` is filled with `napi_value`
+values that represent `undefined`.
+- `[out] this`: Receives the JavaScript `this` argument for the call.
+- `[out] data`: Receives the data pointer for the callback.
+
+Returns `napi_ok` if the API succeeded.
+
+This method is used within a callback function to retrieve details about the
+call like the arguments and the `this` pointer from a given callback info.
+
+### *napi_is_construct_call*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_is_construct_call(napi_env env,
+                                   napi_callback_info cbinfo,
+                                   bool* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] cbinfo`: The callback info passed into the callback function.
+- `[out] result`: Whether the native function is being invoked as
+a constructor call.
+
+Returns `napi_ok` if the API succeeded.
+
+This API checks if the the current callback was due to a
+consructor call.
+
+### *napi_new_instance*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_new_instance(napi_env env,
+                              napi_value cons,
+                              size_t argc,
+                              napi_value* argv,
+                              napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] cons`: `napi_value` representing the JavaScript function
+to be invoked as a constructor.
+- `[in] argc`: The count of elements in the `argv` array.
+- `[in] argv`: Array of JavaScript values as `napi_value`
+representing the arguments to the constructor.
+- `[out] result`: `napi_value` representing the JavaScript object returned,
+which in this case is the constructed object.
+
+This method is used to instantiate a new JavaScript value using a given
+`napi_value` that represents the constructor for the object. For example,
+consider the following snippet:
+```js
+function MyObject(param) {
+  this.param = param;
+}
+
+const arg = 'hello';
+const value = new MyObject(arg);
+```
+
+The following can be approximated in N-API using the following snippet:
+```C
+// Get the constructor function MyObject
+napi_value global, constructor, arg, value;
+napi_status status = napi_get_global(env, &global);
+if (status != napi_ok) return;
+
+status = napi_get_named_property(env, global, "MyObject", &constructor);
+if (status != napi_ok) return;
+
+// const arg = "hello"
+status = napi_create_string_utf8(env, "hello", -1, &arg);
+if (status != napi_ok) return;
+
+napi_value* argv = &arg;
+size_t argc = 1;
+
+// const value = new MyObject(arg)
+status = napi_new_instance(env, constructor, argc, argv, &value);
+```
+
+Returns `napi_ok` if the API succeeded.
+
+### *napi_make_callback*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_make_callback(napi_env env,
+                               napi_value recv,
+                               napi_value func,
+                               int argc,
+                               const napi_value* argv,
+                               napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] recv`: The `this` object passed to the called function.
+- `[in] func`: `napi_value` representing the JavaScript function
+to be invoked.
+- `[in] argc`: The count of elements in the `argv` array.
+- `[in] argv`: Array of JavaScript values as `napi_value`
+representing the arguments to the function.
+- `[out] result`: `napi_value` representing the JavaScript object returned.
+
+Returns `napi_ok` if the API succeeded.
+
+This method allows a JavaScript function object to be called from a native
+add-on. This API is similar to `napi_call_function`. However, it is used to call
+*from* native code back *into* JavaScript *after* returning from an async
+operation (when there is no other script on the stack). It is a fairly simple
+wrapper around `node::MakeCallback`.
+
+For an example on how to use `napi_make_callback`, see the section on
+[Asynchronous Operations][].
+
+## Object Wrap
+
+N-API offers a way to "wrap" C++ classes and instances so that the class
+constructor and methods can be called from JavaScript.
+
+ 1. The [`napi_define_class`][] API defines a JavaScript class with constructor,
+    static properties and methods, and instance properties and methods that
+    correspond to the The C++ class.
+ 2. When JavaScript code invokes the constructor, the constructor callback
+    uses [`napi_wrap`][] to wrap a new C++ instance in a JavaScript object,
+    then returns the wrapper object.
+ 3. When JavaScript code invokes a method or property accessor on the class,
+    the corresponding `napi_callback` C++ function is invoked. For an instance
+    callback, [`napi_unwrap`][] obtains the C++ instance that is the target of
+    the call.
+
+### *napi_define_class*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_define_class(napi_env env,
+                              const char* utf8name,
+                              napi_callback constructor,
+                              void* data,
+                              size_t property_count,
+                              const napi_property_descriptor* properties,
+                              napi_value* result);
+```
+
+ - `[in] env`: The environment that the API is invoked under.
+ - `[in] utf8name`: Name of the JavaScript constructor function; this is
+   not required to be the same as the C++ class name, though it is recommended
+   for clarity.
+ - `[in] constructor`: Callback function that handles constructing instances
+   of the class. (This should be a static method on the class, not an actual
+   C++ constructor function.)
+ - `[in] data`: Optional data to be passed to the constructor callback as
+   the `data` property of the callback info.
+ - `[in] property_count`: Number of items in the `properties` array argument.
+ - `[in] properties`: Array of property descriptors describing static and
+   instance data properties, accessors, and methods on the class
+   See `napi_property_descriptor`.
+ - `[out] result`: A `napi_value` representing the constructor function for
+   the class.
+
+Returns `napi_ok` if the API succeeded.
+
+Defines a JavaScript class that corresponds to a C++ class, including:
+ - A JavaScript constructor function that has the class name and invokes the
+   provided C++ constructor callback.
+ - Properties on the constructor function corresponding to _static_ data
+   properties, accessors, and methods of the C++ class (defined by
+   property descriptors with the `napi_static` attribute).
+ - Properties on the constructor function's `prototype` object corresponding to
+   _non-static_ data properties, accessors, and methods of the C++ class
+   (defined by property descriptors without the `napi_static` attribute).
+
+The C++ constructor callback should be a static method on the class that calls
+the actual class constructor, then wraps the new C++ instance in a JavaScript
+object, and returns the wrapper object. See `napi_wrap()` for details.
+
+The JavaScript constructor function returned from [`napi_define_class`][] is
+often saved and used later, to construct new instances of the class from native
+code, and/or check whether provided values are instances of the class. In that
+case, to prevent the function value from being garbage-collected, create a
+persistent reference to it using [`napi_create_reference`][] and ensure the
+reference count is kept >= 1.
+
+### *napi_wrap*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_wrap(napi_env env,
+                      napi_value js_object,
+                      void* native_object,
+                      napi_finalize finalize_cb,
+                      void* finalize_hint,
+                      napi_ref* result);
+```
+
+ - `[in] env`: The environment that the API is invoked under.
+ - `[in] js_object`: The JavaScript object that will be the wrapper for the
+   native object. This object _must_ have been created from the `prototype` of
+   a constructor that was created using `napi_define_class()`.
+ - `[in] native_object`: The native instance that will be wrapped in the
+   JavaScript object.
+ - `[in] finalize_cb`: Optional native callback that can be used to free the
+   native instance when the JavaScript object is ready for garbage-collection.
+ - `[in] finalize_hint`: Optional contextual hint that is passed to the
+   finalize callback.
+ - `[out] result`: Optional reference to the wrapped object.
+
+Returns `napi_ok` if the API succeeded.
+
+Wraps a native instance in JavaScript object of the corresponding type.
+
+When JavaScript code invokes a constructor for a class that was defined using
+`napi_define_class()`, the `napi_callback` for the constructor is invoked.
+After constructing an instance of the native class, the callback must then call
+`napi_wrap()` to wrap the newly constructed instance in the already-created
+JavaScript object that is the `this` argument to the constructor callback.
+(That `this` object was created from the constructor function's `prototype`,
+so it already has definitions of all the instance properties and methods.)
+
+Typically when wrapping a class instance, a finalize callback should be
+provided that simply deletes the native instance that is received as the `data`
+argument to the finalize callback.
+
+The optional returned reference is initially a weak reference, meaning it
+has a reference count of 0. Typically this reference count would be incremented
+temporarily during async operations that require the instance to remain valid.
+
+Caution: The optional returned reference (if obtained) should be deleted via
+[`napi_delete_reference`][] ONLY in response to the finalize callback invocation.
+(If it is deleted before then, then the finalize callback may never be
+invoked.) Therefore when obtaining a reference a finalize callback is also
+required in order to enable correct proper of the reference.
+
+### *napi_unwrap*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+napi_status napi_unwrap(napi_env env,
+                        napi_value js_object,
+                        void** result);
+```
+
+ - `[in] env`: The environment that the API is invoked under.
+ - `[in] js_object`: The object associated with the C++ class instance.
+ - `[out] result`: Pointer to the wrapped C++ class instance.
+
+Returns `napi_ok` if the API succeeded.
+
+When JavaScript code invokes a method or property accessor on the class, the
+corresponding `napi_callback` is invoked. If the callback is for an instance
+method or accessor, then the `this` argument to the callback is the wrapper
+object; the wrapped C++ instance that is the target of the call can be obtained
+then by calling `napi_unwrap()` on the wrapper object.
+
+## Asynchronous Operations
+
+Addon modules often need to leverage async helpers from libuv as part of their
+implementation. This allows them to schedule work to be executed asynchronously
+so that their methods can return in advance of the work being completed. This
+is important in order to allow them to avoid blocking overall execution
+of the Node.js application.
+
+N-API provides an ABI-stable interface for these
+supporting functions which covers the most common asynchronous use cases.
+
+N-API defines the `napi_work` structure which is used to manage
+asynchronous workers. Instances are created/deleted with
+[`napi_create_async_work`][] and [`napi_delete_async_work`][].
+
+The `execute` and `complete` callbacks are functions that will be
+invoked when the executor is ready to execute and when it completes its
+task respectively. These functions implement the following interfaces:
+
+```C
+typedef void (*napi_async_execute_callback)(napi_env env,
+                                            void* data);
+typedef void (*napi_async_complete_callback)(napi_env env,
+                                             napi_status status,
+                                             void* data);
+```
+
+
+When these methods are invoked, the `data` parameter passed will be the
+addon-provided void* data that was passed into the
+`napi_create_async_work` call.
+
+Once created the async worker can be queued
+for execution using the [`napi_queue_async_work`][] function:
+
+```C
+NAPI_EXTERN napi_status napi_queue_async_work(napi_env env,
+                                              napi_async_work work);
+```
+
+[`napi_cancel_async_work`][] can be used if  the work needs
+to be cancelled before the work has started execution.
+
+After calling [`napi_cancel_async_work`][], the `complete` callback
+will be invoked with a status value of `napi_cancelled`.
+The work should not be deleted before the `complete`
+callback invocation, even when it was cancelled.
+
+**Note:** As mentioned in the section on memory management, if
+the code to be run in the callbacks will create N-API values, then
+N-API handle scope functions must be used to create/destroy a
+`napi_handle_scope` such that the scope is active when
+objects can be created.
+
+
+### napi_create_async_work
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NAPI_EXTERN
+napi_status napi_create_async_work(napi_env env,
+                                   napi_async_execute_callback execute,
+                                   napi_async_complete_callback complete,
+                                   void* data,
+                                   napi_async_work* result);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] execute`: The native function which should be called to excute
+the logic asynchronously.
+- `[in] complete`: The native function which will be called when the
+asynchronous logic is comple or is cancelled.
+- `[in] data`: User-provided data context. This will be passed back into the
+execute and complete functions.
+- `[out] result`: `napi_async_work*` which is the handle to the newly created
+async work.
+
+Returns `napi_ok` if the API succeeded.
+
+This API allocates a work object that is used to execute logic asynchronously.
+It should be freed using [`napi_delete_async_work`][] once the work is no longer
+required.
+
+### napi_delete_async_work
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NAPI_EXTERN napi_status napi_delete_async_work(napi_env env,
+                                               napi_async_work work);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] work`: The handle returned by the call to `napi_create_async_work`.
+
+Returns `napi_ok` if the API succeeded.
+
+This API frees a previously allocated work object.
+
+### napi_queue_async_work
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NAPI_EXTERN napi_status napi_queue_async_work(napi_env env,
+                                              napi_async_work work);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] work`: The handle returned by the call to `napi_create_async_work`.
+
+Returns `napi_ok` if the API succeeded.
+
+This API requests that the previously allocated work be scheduled
+for execution.
+
+### napi_cancel_async_work
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NAPI_EXTERN napi_status napi_cancel_async_work(napi_env env,
+                                               napi_async_work work);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] work`: The handle returned by the call to `napi_create_async_work`.
+
+Returns `napi_ok` if the API succeeded.
+
+This API cancels a previously allocated work, provided
+it has not yet been queued for execution. After this function is called
+the `complete` callback will be invoked with a status value of
+`napi_cancelled`. The work should not be deleted before the `complete`
+callback invocation, even when it was cancelled.
+
+
+[Aynchronous Operations]: #n_api_asynchronous_operations
+[Basic N-API Data Types]: #n_api_basic_n_api_data_types
+[ECMAScript Language Specification]: https://tc39.github.io/ecma262/
+[Error Handling]: #n_api_error_handling
+[Module Registration]: #n_api_module_registration
+[Native Abstractions for Node.js]: https://github.com/nodejs/nan
+[Object Lifetime Management]: #n_api_object_lifetime_management
+[Object Wrap]: #n_api_object_wrap
+[Section 9.1.6]: https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-defineownproperty-p-desc
+[Section 12.5.5]: https://tc39.github.io/ecma262/#sec-typeof-operator
+[Working with JavaScript Functions]: #n_api_working_with_javascript_functions
+[Working with JavaScript Properties]: #n_api_working_with_javascript_properties
+[Working with JavaScript Values]: #n_api_working_with_javascript_values
+[Working with JavaScript Values - Abstract Operations]: #n_api_working_with_javascript_values_abstract_operations
+
+[`napi_cancel_async_work`]: #n_api_napi_cancel_async_work
+[`napi_close_escapable_handle_scope`]: #n_api_napi_close_escapable_handle_scope
+[`napi_close_handle_scope`]: #n_api_napi_close_handle_scope
+[`napi_create_async_work`]: #n_api_napi_create_async_work
+[`napi_create_error`]: #n_api_napi_create_error
+[`napi_create_external_arraybuffer`][]: #n_api_napi_create_external_arraybuffer
+[`napi_create_range_error`]: #n_api_napi_create_range_error
+[`napi_create_reference`]: #n_api_napi_create_reference
+[`napi_create_type_error`]: #n_api_napi_create_type_error
+[`napi_define_class`]: #n_api_napi_define_class
+[`napi_delete_async_work`]: #n_api_napi_delete_async_work
+[`napi_define_class`][]: #n_api_napi_define_class
+[`napi_delete_reference`]: #n_api_napi_delete_reference
+[`napi_escape_handle`]: #n_api_napi_escape_handle
+[`napi_get_array_length`]: #n_api_napi_get_array_length
+[`napi_get_element`]: #n_api_napi_get_element
+[`napi_get_property`]: #n_api_napi_get_property
+[`napi_has_property`]: #n_api_napi_has_property
+[`napi_set_property`]: #n_api_napi_set_property
+[`napi_get_reference_value`]: #n_api_napi_get_reference_value
+[`napi_is_error`]: #n_api_napi_is_error
+[`napi_is_exception_pending`]: #n_api_napi_is_exception_pending
+[`napi_get_last_error_info`]: #n_api_napi_get_last_error_info
+[`napi_get_and_clear_last_exception`]: #n_api_napi_get_and_clear_last_exception
+[`napi_make_callback`]: #n_api_napi_make_callback
+[`napi_open_escapable_handle_scope`]: #n_api_napi_open_escapable_handle_scope
+[`napi_open_handle_scope`]: #n_api_napi_open_handle_scope
+[`napi_property_descriptor`]: #n_api_napi_property_descriptor
+[`napi_queue_async_work`]: #n_api_napi_queue_async_work
+[`napi_reference_ref`]: #n_api_napi_reference_ref
+[`napi_reference_unref`]: #n_api_napi_reference_unref
+[`napi_throw_error`]: #n_api_napi_throw_error
+[`napi_throw_range_error`]: #n_api_napi_throw_range_error
+[`napi_throw_type_error`]: #n_api_napi_throw_type_error
+[`napi_unwrap`]: #n_api_napi_unwrap
+[`napi_wrap`]: #n_api_napi_wrap

From 3461bc13da995e90031c18b8e9d7237d7b5c0106 Mon Sep 17 00:00:00 2001
From: gwer <webholt@gmail.com>
Date: Sun, 23 Apr 2017 02:01:54 +0300
Subject: [PATCH 026/183] test: replace indexOf with includes

Start the transition to Array.prototype.includes() and
String.prototype.includes().  This commit refactors most of the
comparisons of Array.prototype.indexOf() and String.prototype.indexOf()
return values with -1 to the former methods in tests.

PR-URL: https://github.com/nodejs/node/pull/12604
Refs: https://github.com/nodejs/node/issues/12586
Reviewed-By: Alexey Orlenko <eaglexrlnk@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Gibson Fahnestock <gibfahn@gmail.com>
---
 test/addons-napi/test_constructor/test.js | 16 ++++++++--------
 test/addons-napi/test_properties/test.js  | 16 ++++++++--------
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/test/addons-napi/test_constructor/test.js b/test/addons-napi/test_constructor/test.js
index 92440bf49e74c1..26083db7a28a21 100644
--- a/test/addons-napi/test_constructor/test.js
+++ b/test/addons-napi/test_constructor/test.js
@@ -22,14 +22,14 @@ const propertyNames = [];
 for (const name in test_object) {
   propertyNames.push(name);
 }
-assert.ok(propertyNames.indexOf('echo') >= 0);
-assert.ok(propertyNames.indexOf('readwriteValue') >= 0);
-assert.ok(propertyNames.indexOf('readonlyValue') >= 0);
-assert.ok(propertyNames.indexOf('hiddenValue') < 0);
-assert.ok(propertyNames.indexOf('readwriteAccessor1') < 0);
-assert.ok(propertyNames.indexOf('readwriteAccessor2') < 0);
-assert.ok(propertyNames.indexOf('readonlyAccessor1') < 0);
-assert.ok(propertyNames.indexOf('readonlyAccessor2') < 0);
+assert.ok(propertyNames.includes('echo'));
+assert.ok(propertyNames.includes('readwriteValue'));
+assert.ok(propertyNames.includes('readonlyValue'));
+assert.ok(!propertyNames.includes('hiddenValue'));
+assert.ok(!propertyNames.includes('readwriteAccessor1'));
+assert.ok(!propertyNames.includes('readwriteAccessor2'));
+assert.ok(!propertyNames.includes('readonlyAccessor1'));
+assert.ok(!propertyNames.includes('readonlyAccessor2'));
 
 // The napi_writable attribute should be ignored for accessors.
 test_object.readwriteAccessor1 = 1;
diff --git a/test/addons-napi/test_properties/test.js b/test/addons-napi/test_properties/test.js
index 868c603879f1a2..a8127a27860eb3 100644
--- a/test/addons-napi/test_properties/test.js
+++ b/test/addons-napi/test_properties/test.js
@@ -21,14 +21,14 @@ const propertyNames = [];
 for (const name in test_object) {
   propertyNames.push(name);
 }
-assert.ok(propertyNames.indexOf('echo') >= 0);
-assert.ok(propertyNames.indexOf('readwriteValue') >= 0);
-assert.ok(propertyNames.indexOf('readonlyValue') >= 0);
-assert.ok(propertyNames.indexOf('hiddenValue') < 0);
-assert.ok(propertyNames.indexOf('readwriteAccessor1') < 0);
-assert.ok(propertyNames.indexOf('readwriteAccessor2') < 0);
-assert.ok(propertyNames.indexOf('readonlyAccessor1') < 0);
-assert.ok(propertyNames.indexOf('readonlyAccessor2') < 0);
+assert.ok(propertyNames.includes('echo'));
+assert.ok(propertyNames.includes('readwriteValue'));
+assert.ok(propertyNames.includes('readonlyValue'));
+assert.ok(!propertyNames.includes('hiddenValue'));
+assert.ok(!propertyNames.includes('readwriteAccessor1'));
+assert.ok(!propertyNames.includes('readwriteAccessor2'));
+assert.ok(!propertyNames.includes('readonlyAccessor1'));
+assert.ok(!propertyNames.includes('readonlyAccessor2'));
 
 // The napi_writable attribute should be ignored for accessors.
 test_object.readwriteAccessor1 = 1;

From b91ac1014e014ddf006f4ca7727d04645285a8ce Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Thu, 27 Apr 2017 17:27:05 -0700
Subject: [PATCH 027/183] test,lib,doc: use function declarations

Replace function expressions with function declarations in preparation
for a lint rule requiring function declarations.

PR-URL: https://github.com/nodejs/node/pull/12711
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Gibson Fahnestock <gibfahn@gmail.com>
---
 test/addons-napi/test_async/test.js      | 5 ++---
 test/addons-napi/test_exception/test.js  | 6 +++---
 test/addons-napi/test_instanceof/test.js | 4 ++--
 3 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/test/addons-napi/test_async/test.js b/test/addons-napi/test_async/test.js
index 7c140d79fc054f..2b4577624a371e 100644
--- a/test/addons-napi/test_async/test.js
+++ b/test/addons-napi/test_async/test.js
@@ -6,8 +6,7 @@ const test_async = require(`./build/${common.buildType}/test_async`);
 test_async.Test(5, common.mustCall(function(err, val) {
   assert.strictEqual(err, null);
   assert.strictEqual(val, 10);
-  process.nextTick(common.mustCall(function() {}));
+  process.nextTick(common.mustCall());
 }));
 
-const cancelSuceeded = function() {};
-test_async.TestCancel(common.mustCall(cancelSuceeded));
+test_async.TestCancel(common.mustCall());
diff --git a/test/addons-napi/test_exception/test.js b/test/addons-napi/test_exception/test.js
index 83d2b5000ec54a..94f9566a4b341f 100644
--- a/test/addons-napi/test_exception/test.js
+++ b/test/addons-napi/test_exception/test.js
@@ -4,12 +4,12 @@ const common = require('../../common');
 const test_exception = require(`./build/${common.buildType}/test_exception`);
 const assert = require('assert');
 const theError = new Error('Some error');
-const throwTheError = function() {
+function throwTheError() {
   throw theError;
-};
+}
 let caughtError;
 
-const throwNoError = function() {};
+const throwNoError = common.noop;
 
 // Test that the native side successfully captures the exception
 let returnedError = test_exception.returnException(throwTheError);
diff --git a/test/addons-napi/test_instanceof/test.js b/test/addons-napi/test_instanceof/test.js
index 38d17031e9a6c9..418149d1909e6f 100644
--- a/test/addons-napi/test_instanceof/test.js
+++ b/test/addons-napi/test_instanceof/test.js
@@ -57,14 +57,14 @@ if (typeof Symbol !== 'undefined' && 'hasInstance' in Symbol &&
       (theObject instanceof theConstructor));
   }
 
-  const MyClass = function MyClass() {};
+  function MyClass() {}
   Object.defineProperty(MyClass, Symbol.hasInstance, {
     value: function(candidate) {
       return 'mark' in candidate;
     }
   });
 
-  const MySubClass = function MySubClass() {};
+  function MySubClass() {}
   MySubClass.prototype = new MyClass();
 
   let x = new MySubClass();

From e89a91172b2cc7e5097d2b3791b0d9f1d2a8064b Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Thu, 27 Apr 2017 22:15:36 +0300
Subject: [PATCH 028/183] n-api: remove unnecessary try-catch bracket from
 certain APIs

These APIs do not need a try-catch around their body, because no
exceptions are thrown in their implementation:
- `napi_is_array()`
- `napi_get_value_string_latin1()`
- `napi_get_value_string_utf8()`
- `napi_get_value_string_utf16()`
- `napi_get_value_external()`
- `napi_is_buffer()`
- `napi_is_arraybuffer()`
- `napi_get_arraybuffer_info()`
- `napi_is_typedarray()`
- `napi_get_typedarray_info()`

Fixes: https://github.com/nodejs/abi-stable-node/issues/238
PR-URL: https://github.com/nodejs/node/pull/12705
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 src/node_api.cc | 42 +++++++++++++++++++++---------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index d1ca7bec27c269..4113124b093419 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -1209,14 +1209,14 @@ napi_status napi_define_properties(napi_env env,
 }
 
 napi_status napi_is_array(napi_env env, napi_value value, bool* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
 
   *result = val->IsArray();
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_get_array_length(napi_env env,
@@ -1777,7 +1777,7 @@ napi_status napi_get_value_string_latin1(napi_env env,
                                          char* buf,
                                          size_t bufsize,
                                          size_t* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, value);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
@@ -1797,7 +1797,7 @@ napi_status napi_get_value_string_latin1(napi_env env,
     }
   }
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 // Copies a JavaScript string into a UTF-8 string buffer. The result is the
@@ -1813,7 +1813,7 @@ napi_status napi_get_value_string_utf8(napi_env env,
                                        char* buf,
                                        size_t bufsize,
                                        size_t* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, value);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
@@ -1833,7 +1833,7 @@ napi_status napi_get_value_string_utf8(napi_env env,
     }
   }
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 // Copies a JavaScript string into a UTF-16 string buffer. The result is the
@@ -1849,7 +1849,7 @@ napi_status napi_get_value_string_utf16(napi_env env,
                                         char16_t* buf,
                                         size_t bufsize,
                                         size_t* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, value);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
@@ -1870,7 +1870,7 @@ napi_status napi_get_value_string_utf16(napi_env env,
     }
   }
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_coerce_to_object(napi_env env,
@@ -2024,13 +2024,13 @@ napi_status napi_create_external(napi_env env,
 
   *result = v8impl::JsValueFromV8LocalValue(external_value);
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_get_value_external(napi_env env,
                                     napi_value value,
                                     void** result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
@@ -2040,7 +2040,7 @@ napi_status napi_get_value_external(napi_env env,
   v8::Local<v8::External> external_value = val.As<v8::External>();
   *result = external_value->Value();
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 // Set initial_refcount to 0 for a weak reference, >0 for a strong reference.
@@ -2481,12 +2481,12 @@ napi_status napi_create_buffer_copy(napi_env env,
 }
 
 napi_status napi_is_buffer(napi_env env, napi_value value, bool* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
   *result = node::Buffer::HasInstance(v8impl::V8LocalValueFromJsValue(value));
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_get_buffer_info(napi_env env,
@@ -2510,14 +2510,14 @@ napi_status napi_get_buffer_info(napi_env env,
 }
 
 napi_status napi_is_arraybuffer(napi_env env, napi_value value, bool* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
   *result = val->IsArrayBuffer();
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_create_arraybuffer(napi_env env,
@@ -2574,7 +2574,7 @@ napi_status napi_get_arraybuffer_info(napi_env env,
                                       napi_value arraybuffer,
                                       void** data,
                                       size_t* byte_length) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, arraybuffer);
 
   v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(arraybuffer);
@@ -2591,18 +2591,18 @@ napi_status napi_get_arraybuffer_info(napi_env env,
     *byte_length = contents.ByteLength();
   }
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_is_typedarray(napi_env env, napi_value value, bool* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
   *result = val->IsTypedArray();
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_create_typedarray(napi_env env,
@@ -2664,7 +2664,7 @@ napi_status napi_get_typedarray_info(napi_env env,
                                      void** data,
                                      napi_value* arraybuffer,
                                      size_t* byte_offset) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, typedarray);
 
   v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(typedarray);
@@ -2712,7 +2712,7 @@ napi_status napi_get_typedarray_info(napi_env env,
     *byte_offset = array->ByteOffset();
   }
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 namespace uvimpl {

From f14a0bb840437a39c5bbaa1bc24e259414284577 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Fri, 28 Apr 2017 15:56:21 -0400
Subject: [PATCH 029/183] test: fix warning in n-api reference test

Add cast to avoid warning during build of addon.

PR-URL: https://github.com/nodejs/node/pull/12730
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 test/addons-napi/test_reference/test_reference.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/addons-napi/test_reference/test_reference.c b/test/addons-napi/test_reference/test_reference.c
index 1a238a560aac53..9be9fd135fb0e9 100644
--- a/test/addons-napi/test_reference/test_reference.c
+++ b/test/addons-napi/test_reference/test_reference.c
@@ -60,10 +60,10 @@ napi_value CheckExternal(napi_env env, napi_callback_info info) {
 
   NAPI_ASSERT(env, argtype == napi_external, "Expected an external value.")
 
-  int* data;
+  void* data;
   NAPI_CALL(env, napi_get_value_external(env, arg, &data));
 
-  NAPI_ASSERT(env, data != NULL && *data == test_value,
+  NAPI_ASSERT(env, data != NULL && *(int*)data == test_value,
     "An external data value of 1 was expected.")
 
   return NULL;

From 269e921a8b675718a0fbd7f95e0007996cbcc7b8 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Fri, 28 Apr 2017 15:28:34 -0400
Subject: [PATCH 030/183] test: add coverage for error apis

Add coverage for N-API functions related to
throwing and creating errors.  A number of these
are currently showing as not having any
coverage in the nightly code coverage reports.

PR-URL: https://github.com/nodejs/node/pull/12729
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/addons-napi/test_error/test.js       | 34 ++++++++++++++
 test/addons-napi/test_error/test_error.cc | 55 +++++++++++++++++++++++
 2 files changed, 89 insertions(+)

diff --git a/test/addons-napi/test_error/test.js b/test/addons-napi/test_error/test.js
index 521c29250d5ffa..f7479f2c9a64d8 100644
--- a/test/addons-napi/test_error/test.js
+++ b/test/addons-napi/test_error/test.js
@@ -55,3 +55,37 @@ assert.strictEqual(test_error.checkError({}), false,
 // Test that non-error primitive is correctly classed
 assert.strictEqual(test_error.checkError('non-object'), false,
                    'Non-error primitive correctly classed by napi_is_error');
+
+assert.throws(() => {
+  test_error.throwExistingError();
+}, /^Error: existing error$/);
+
+assert.throws(() => {
+  test_error.throwError();
+}, /^Error: error$/);
+
+assert.throws(() => {
+  test_error.throwRangeError();
+}, /^RangeError: range error$/);
+
+assert.throws(() => {
+  test_error.throwTypeError();
+}, /^TypeError: type error$/);
+
+let error = test_error.createError();
+assert.ok(error instanceof Error, 'expected error to be an instance of Error');
+assert.strictEqual(error.message, 'error', 'expected message to be "error"');
+
+error = test_error.createRangeError();
+assert.ok(error instanceof RangeError,
+          'expected error to be an instance of RangeError');
+assert.strictEqual(error.message,
+                   'range error',
+                   'expected message to be "range error"');
+
+error = test_error.createTypeError();
+assert.ok(error instanceof TypeError,
+          'expected error to be an instance of TypeError');
+assert.strictEqual(error.message,
+                   'type error',
+                   'expected message to be "type error"');
diff --git a/test/addons-napi/test_error/test_error.cc b/test/addons-napi/test_error/test_error.cc
index eb616cac371b0c..ddba2059f23be6 100644
--- a/test/addons-napi/test_error/test_error.cc
+++ b/test/addons-napi/test_error/test_error.cc
@@ -15,9 +15,64 @@ napi_value checkError(napi_env env, napi_callback_info info) {
   return result;
 }
 
+napi_value throwExistingError(napi_env env, napi_callback_info info) {
+  napi_value message;
+  napi_value error;
+  NAPI_CALL(env, napi_create_string_utf8(env, "existing error", -1, &message));
+  NAPI_CALL(env, napi_create_error(env, message, &error));
+  NAPI_CALL(env, napi_throw(env, error));
+  return nullptr;
+}
+
+napi_value throwError(napi_env env, napi_callback_info info) {
+  NAPI_CALL(env, napi_throw_error(env, "error"));
+  return nullptr;
+}
+
+napi_value throwRangeError(napi_env env, napi_callback_info info) {
+  NAPI_CALL(env, napi_throw_range_error(env, "range error"));
+  return nullptr;
+}
+
+napi_value throwTypeError(napi_env env, napi_callback_info info) {
+  NAPI_CALL(env, napi_throw_type_error(env, "type error"));
+  return nullptr;
+}
+
+napi_value createError(napi_env env, napi_callback_info info) {
+  napi_value result;
+  napi_value message;
+  NAPI_CALL(env, napi_create_string_utf8(env, "error", -1, &message));
+  NAPI_CALL(env, napi_create_error(env, message, &result));
+  return result;
+}
+
+napi_value createRangeError(napi_env env, napi_callback_info info) {
+  napi_value result;
+  napi_value message;
+  NAPI_CALL(env, napi_create_string_utf8(env, "range error", -1, &message));
+  NAPI_CALL(env, napi_create_range_error(env, message, &result));
+  return result;
+}
+
+napi_value createTypeError(napi_env env, napi_callback_info info) {
+  napi_value result;
+  napi_value message;
+  NAPI_CALL(env, napi_create_string_utf8(env, "type error", -1, &message));
+  NAPI_CALL(env, napi_create_type_error(env, message, &result));
+  return result;
+}
+
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("checkError", checkError),
+    DECLARE_NAPI_PROPERTY("throwExistingError", throwExistingError),
+    DECLARE_NAPI_PROPERTY("throwError", throwError),
+    DECLARE_NAPI_PROPERTY("throwRangeError", throwRangeError),
+    DECLARE_NAPI_PROPERTY("throwTypeError", throwTypeError),
+    DECLARE_NAPI_PROPERTY("createError", createError),
+    DECLARE_NAPI_PROPERTY("createRangeError", createRangeError),
+    DECLARE_NAPI_PROPERTY("createTypeError", createTypeError),
   };
 
   NAPI_CALL_RETURN_VOID(env, napi_define_properties(

From ed2ef69c55fd2a5ea40a2086820dde1278b294e7 Mon Sep 17 00:00:00 2001
From: Hitesh Kanwathirtha <hiteshk@microsoft.com>
Date: Thu, 13 Apr 2017 20:21:52 -0700
Subject: [PATCH 031/183] test: port test for make_callback to n-api

Improved test coverage for napi_make_callback by porting the
existing addons/make_callback test to n-api

PR-URL: https://github.com/nodejs/node/pull/12409
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>
---
 .../addons-napi/test_make_callback/binding.cc |  48 ++++++
 .../test_make_callback/binding.gyp            |   9 ++
 test/addons-napi/test_make_callback/test.js   |  83 ++++++++++
 .../test_make_callback_recurse/binding.cc     |  32 ++++
 .../test_make_callback_recurse/binding.gyp    |   9 ++
 .../test_make_callback_recurse/test.js        | 151 ++++++++++++++++++
 6 files changed, 332 insertions(+)
 create mode 100644 test/addons-napi/test_make_callback/binding.cc
 create mode 100644 test/addons-napi/test_make_callback/binding.gyp
 create mode 100644 test/addons-napi/test_make_callback/test.js
 create mode 100644 test/addons-napi/test_make_callback_recurse/binding.cc
 create mode 100644 test/addons-napi/test_make_callback_recurse/binding.gyp
 create mode 100644 test/addons-napi/test_make_callback_recurse/test.js

diff --git a/test/addons-napi/test_make_callback/binding.cc b/test/addons-napi/test_make_callback/binding.cc
new file mode 100644
index 00000000000000..987b024098598c
--- /dev/null
+++ b/test/addons-napi/test_make_callback/binding.cc
@@ -0,0 +1,48 @@
+#include <node_api.h>
+#include "../common.h"
+#include <vector>
+
+namespace {
+
+napi_value MakeCallback(napi_env env, napi_callback_info info) {
+  const int kMaxArgs = 10;
+  size_t argc = kMaxArgs;
+  napi_value args[kMaxArgs];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
+
+  napi_value recv = args[0];
+  napi_value func = args[1];
+
+  std::vector<napi_value> argv;
+  for (size_t n = 2; n < argc; n += 1) {
+    argv.push_back(args[n]);
+  }
+
+  napi_valuetype func_type;
+
+  NAPI_CALL(env, napi_typeof(env, func, &func_type));
+
+  napi_value result;
+  if (func_type == napi_function) {
+    NAPI_CALL(env,
+      napi_make_callback(env, recv, func, argv.size(), argv.data(), &result));
+  } else {
+    NAPI_ASSERT(env, false, "Unexpected argument type");
+  }
+
+  return result;
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_value fn;
+  NAPI_CALL_RETURN_VOID(env,
+    napi_create_function(env, NULL, MakeCallback, NULL, &fn));
+  NAPI_CALL_RETURN_VOID(env,
+    napi_set_named_property(env, exports, "makeCallback", fn));
+}
+
+}  // namespace
+
+NAPI_MODULE(binding, Init)
diff --git a/test/addons-napi/test_make_callback/binding.gyp b/test/addons-napi/test_make_callback/binding.gyp
new file mode 100644
index 00000000000000..7ede63d94a0d77
--- /dev/null
+++ b/test/addons-napi/test_make_callback/binding.gyp
@@ -0,0 +1,9 @@
+{
+  'targets': [
+    {
+      'target_name': 'binding',
+      'defines': [ 'V8_DEPRECATION_WARNINGS=1' ],
+      'sources': [ 'binding.cc' ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_make_callback/test.js b/test/addons-napi/test_make_callback/test.js
new file mode 100644
index 00000000000000..c4f24872bdb78e
--- /dev/null
+++ b/test/addons-napi/test_make_callback/test.js
@@ -0,0 +1,83 @@
+'use strict';
+
+const common = require('../../common');
+const assert = require('assert');
+const vm = require('vm');
+const binding = require(`./build/${common.buildType}/binding`);
+const makeCallback = binding.makeCallback;
+
+function myMultiArgFunc(arg1, arg2, arg3) {
+  console.log(`MyFunc was called with ${arguments.length} arguments`);
+  assert.strictEqual(arg1, 1);
+  assert.strictEqual(arg2, 2);
+  assert.strictEqual(arg3, 3);
+  return 42;
+}
+
+assert.strictEqual(42, makeCallback(process, common.mustCall(function() {
+  assert.strictEqual(0, arguments.length);
+  assert.strictEqual(this, process);
+  return 42;
+})));
+
+assert.strictEqual(42, makeCallback(process, common.mustCall(function(x) {
+  assert.strictEqual(1, arguments.length);
+  assert.strictEqual(this, process);
+  assert.strictEqual(x, 1337);
+  return 42;
+}), 1337));
+
+assert.strictEqual(42,
+                   makeCallback(this,
+                                common.mustCall(myMultiArgFunc), 1, 2, 3));
+
+// TODO(node-api): napi_make_callback needs to support
+// strings passed for the func argument
+/*
+const recv = {
+  one: common.mustCall(function() {
+    assert.strictEqual(0, arguments.length);
+    assert.strictEqual(this, recv);
+    return 42;
+  }),
+  two: common.mustCall(function(x) {
+    assert.strictEqual(1, arguments.length);
+    assert.strictEqual(this, recv);
+    assert.strictEqual(x, 1337);
+    return 42;
+  }),
+};
+
+assert.strictEqual(42, makeCallback(recv, 'one'));
+assert.strictEqual(42, makeCallback(recv, 'two', 1337));
+
+// Check that callbacks on a receiver from a different context works.
+const foreignObject = vm.runInNewContext('({ fortytwo() { return 42; } })');
+assert.strictEqual(42, makeCallback(foreignObject, 'fortytwo'));
+*/
+
+// Check that the callback is made in the context of the receiver.
+const target = vm.runInNewContext(`
+    (function($Object) {
+      if (Object === $Object)
+        throw new Error('bad');
+      return Object;
+    })
+`);
+assert.notStrictEqual(Object, makeCallback(process, target, Object));
+
+// Runs in inner context.
+const forward = vm.runInNewContext(`
+    (function(forward) {
+      return forward(Object);
+    })
+`);
+
+// Runs in outer context.
+function endpoint($Object) {
+  if (Object === $Object)
+    throw new Error('bad');
+  return Object;
+}
+
+assert.strictEqual(Object, makeCallback(process, forward, endpoint));
diff --git a/test/addons-napi/test_make_callback_recurse/binding.cc b/test/addons-napi/test_make_callback_recurse/binding.cc
new file mode 100644
index 00000000000000..3f5a4c28b43524
--- /dev/null
+++ b/test/addons-napi/test_make_callback_recurse/binding.cc
@@ -0,0 +1,32 @@
+#include <node_api.h>
+#include "../common.h"
+#include <vector>
+
+namespace {
+
+napi_value MakeCallback(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value args[2];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  napi_value recv = args[0];
+  napi_value func = args[1];
+
+  napi_make_callback(env,
+    recv, func, 0 /* argc */, nullptr /* argv */, nullptr /* result */);
+
+  return recv;
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_value fn;
+  NAPI_CALL_RETURN_VOID(env,
+    napi_create_function(env, NULL, MakeCallback, NULL, &fn));
+  NAPI_CALL_RETURN_VOID(env,
+    napi_set_named_property(env, exports, "makeCallback", fn));
+}
+
+
+}  // namespace
+
+NAPI_MODULE(binding, Init)
diff --git a/test/addons-napi/test_make_callback_recurse/binding.gyp b/test/addons-napi/test_make_callback_recurse/binding.gyp
new file mode 100644
index 00000000000000..7ede63d94a0d77
--- /dev/null
+++ b/test/addons-napi/test_make_callback_recurse/binding.gyp
@@ -0,0 +1,9 @@
+{
+  'targets': [
+    {
+      'target_name': 'binding',
+      'defines': [ 'V8_DEPRECATION_WARNINGS=1' ],
+      'sources': [ 'binding.cc' ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_make_callback_recurse/test.js b/test/addons-napi/test_make_callback_recurse/test.js
new file mode 100644
index 00000000000000..895769bc33029a
--- /dev/null
+++ b/test/addons-napi/test_make_callback_recurse/test.js
@@ -0,0 +1,151 @@
+'use strict';
+
+const common = require('../../common');
+const assert = require('assert');
+const domain = require('domain');
+const binding = require(`./build/${common.buildType}/binding`);
+const makeCallback = binding.makeCallback;
+
+// Make sure this is run in the future.
+const mustCallCheckDomains = common.mustCall(checkDomains);
+
+
+// Make sure that using MakeCallback allows the error to propagate.
+assert.throws(function() {
+  makeCallback({}, function() {
+    throw new Error('hi from domain error');
+  });
+}, /^Error: hi from domain error$/);
+
+
+// Check the execution order of the nextTickQueue and MicrotaskQueue in
+// relation to running multiple MakeCallback's from bootstrap,
+// node::MakeCallback() and node::AsyncWrap::MakeCallback().
+// TODO(trevnorris): Is there a way to verify this is being run during
+// bootstrap?
+(function verifyExecutionOrder(arg) {
+  const results = [];
+
+  // Processing of the MicrotaskQueue is manually handled by node. They are not
+  // processed until after the nextTickQueue has been processed.
+  Promise.resolve(1).then(common.mustCall(function() {
+    results.push(7);
+  }));
+
+  // The nextTick should run after all immediately invoked calls.
+  process.nextTick(common.mustCall(function() {
+    results.push(3);
+
+    // Run same test again but while processing the nextTickQueue to make sure
+    // the following MakeCallback call breaks in the middle of processing the
+    // queue and allows the script to run normally.
+    process.nextTick(common.mustCall(function() {
+      results.push(6);
+    }));
+
+    makeCallback({}, common.mustCall(function() {
+      results.push(4);
+    }));
+
+    results.push(5);
+  }));
+
+  results.push(0);
+
+  // MakeCallback is calling the function immediately, but should then detect
+  // that a script is already in the middle of execution and return before
+  // either the nextTickQueue or MicrotaskQueue are processed.
+  makeCallback({}, common.mustCall(function() {
+    results.push(1);
+  }));
+
+  // This should run before either the nextTickQueue or MicrotaskQueue are
+  // processed. Previously MakeCallback would not detect this circumstance
+  // and process them immediately.
+  results.push(2);
+
+  setImmediate(common.mustCall(function() {
+    for (let i = 0; i < results.length; i++) {
+      assert.strictEqual(results[i], i,
+                         `verifyExecutionOrder(${arg}) results: ${results}`);
+    }
+    if (arg === 1) {
+      // The tests are first run on bootstrap during LoadEnvironment() in
+      // src/node.cc. Now run the tests through node::MakeCallback().
+      setImmediate(function() {
+        makeCallback({}, common.mustCall(function() {
+          verifyExecutionOrder(2);
+        }));
+      });
+    } else if (arg === 2) {
+      // setTimeout runs via the TimerWrap, which runs through
+      // AsyncWrap::MakeCallback(). Make sure there are no conflicts using
+      // node::MakeCallback() within it.
+      setTimeout(common.mustCall(function() {
+        verifyExecutionOrder(3);
+      }), 10);
+    } else if (arg === 3) {
+      mustCallCheckDomains();
+    } else {
+      throw new Error('UNREACHABLE');
+    }
+  }));
+}(1));
+
+
+function checkDomains() {
+  // Check that domains are properly entered/exited when called in multiple
+  // levels from both node::MakeCallback() and AsyncWrap::MakeCallback
+  setImmediate(common.mustCall(function() {
+    const d1 = domain.create();
+    const d2 = domain.create();
+    const d3 = domain.create();
+
+    makeCallback({domain: d1}, common.mustCall(function() {
+      assert.strictEqual(d1, process.domain);
+      makeCallback({domain: d2}, common.mustCall(function() {
+        assert.strictEqual(d2, process.domain);
+        makeCallback({domain: d3}, common.mustCall(function() {
+          assert.strictEqual(d3, process.domain);
+        }));
+        assert.strictEqual(d2, process.domain);
+      }));
+      assert.strictEqual(d1, process.domain);
+    }));
+  }));
+
+  setTimeout(common.mustCall(function() {
+    const d1 = domain.create();
+    const d2 = domain.create();
+    const d3 = domain.create();
+
+    makeCallback({domain: d1}, common.mustCall(function() {
+      assert.strictEqual(d1, process.domain);
+      makeCallback({domain: d2}, common.mustCall(function() {
+        assert.strictEqual(d2, process.domain);
+        makeCallback({domain: d3}, common.mustCall(function() {
+          assert.strictEqual(d3, process.domain);
+        }));
+        assert.strictEqual(d2, process.domain);
+      }));
+      assert.strictEqual(d1, process.domain);
+    }));
+  }), 1);
+
+  function testTimer(id) {
+    // Make sure nextTick, setImmediate and setTimeout can all recover properly
+    // after a thrown makeCallback call.
+    const d = domain.create();
+    d.on('error', common.mustCall(function(e) {
+      assert.strictEqual(e.message, `throw from domain ${id}`);
+    }));
+    makeCallback({domain: d}, function() {
+      throw new Error(`throw from domain ${id}`);
+    });
+    throw new Error('UNREACHABLE');
+  }
+
+  process.nextTick(common.mustCall(testTimer), 3);
+  setImmediate(common.mustCall(testTimer), 2);
+  setTimeout(common.mustCall(testTimer), 1, 1);
+}

From 7491cee8611b63eb95eb7bbde8335f37d229b7ab Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C3=ABl=20Zasso?= <targos@protonmail.com>
Date: Fri, 5 May 2017 14:43:54 +0200
Subject: [PATCH 032/183] test: fix napi test_reference for recent V8

PR-URL: https://github.com/nodejs/node/pull/12864
Ref: https://github.com/nodejs/node/pull/12551#issuecomment-297949361
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 test/addons-napi/test_reference/test.js | 29 ++++++++++++++-----------
 1 file changed, 16 insertions(+), 13 deletions(-)

diff --git a/test/addons-napi/test_reference/test.js b/test/addons-napi/test_reference/test.js
index ddfec58f1f9d7d..30effe7eec0922 100644
--- a/test/addons-napi/test_reference/test.js
+++ b/test/addons-napi/test_reference/test.js
@@ -33,19 +33,6 @@ assert.strictEqual(test_reference.finalizeCount, 0);
   assert.strictEqual(test_reference.finalizeCount, 1);
 }
 
-{
-  // Weak reference
-  let value = test_reference.createExternalWithFinalize();
-  assert.strictEqual(test_reference.finalizeCount, 0);
-  test_reference.createReference(value, 0);
-  assert.strictEqual(test_reference.referenceValue, value);
-  value = null;
-  global.gc(); // Value should be GC'd because there is only a weak ref
-  assert.strictEqual(test_reference.referenceValue, undefined);
-  assert.strictEqual(test_reference.finalizeCount, 1);
-  test_reference.deleteReference();
-}
-
 {
   // Strong reference
   let value = test_reference.createExternalWithFinalize();
@@ -85,3 +72,19 @@ assert.strictEqual(test_reference.finalizeCount, 0);
   global.gc(); // Value was already GC'd
   assert.strictEqual(test_reference.finalizeCount, 1);
 }
+
+{
+  // Weak reference
+  let value = test_reference.createExternalWithFinalize();
+  assert.strictEqual(test_reference.finalizeCount, 0);
+  test_reference.createReference(value, 0);
+  assert.strictEqual(test_reference.referenceValue, value);
+  value = null;
+  setImmediate(common.mustCall(() => {
+    // This test only works if gc() is called from an immediate callback.
+    global.gc(); // Value should be GC'd because there is only a weak ref
+    assert.strictEqual(test_reference.referenceValue, undefined);
+    assert.strictEqual(test_reference.finalizeCount, 1);
+    test_reference.deleteReference();
+  }));
+}

From 61992ff08528cc78f3916fd1767beec48dfb3fc7 Mon Sep 17 00:00:00 2001
From: Jason Ginchereau <jasongin@microsoft.com>
Date: Fri, 5 May 2017 11:38:21 -0700
Subject: [PATCH 033/183] n-api: napi_get_cb_info should fill array

When the number of args requested is greater than the actual number of
args supplied to the function call, the remainder of the args array
should be filled in with `undefined` values. Because of this bug, the
remainder of the array was left uninitialized, which could cause a
crash.

Refer to the documentation for the `argv` parameter at
https://github.com/nodejs/node/blob/master/doc/api/n-api.md#napi_get_cb_info

PR-URL: https://github.com/nodejs/node/pull/12863
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 src/node_api.cc                                |  2 +-
 test/addons-napi/3_callbacks/binding.c         | 17 +++++++++++++++--
 test/addons-napi/test_function/test_function.c |  2 +-
 3 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 4113124b093419..2f8409fc81627c 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -1526,7 +1526,7 @@ napi_status napi_get_cb_info(
 
   if (argv != nullptr) {
     CHECK_ARG(env, argc);
-    info->Args(argv, std::min(*argc, info->ArgsLength()));
+    info->Args(argv, *argc);
   }
   if (argc != nullptr) {
     *argc = info->ArgsLength();
diff --git a/test/addons-napi/3_callbacks/binding.c b/test/addons-napi/3_callbacks/binding.c
index 47360bd979ffc4..8640a936107d47 100644
--- a/test/addons-napi/3_callbacks/binding.c
+++ b/test/addons-napi/3_callbacks/binding.c
@@ -3,10 +3,23 @@
 #include <string.h>
 
 napi_value RunCallback(napi_env env, napi_callback_info info) {
-  size_t argc = 1;
-  napi_value args[1];
+  size_t argc = 2;
+  napi_value args[2];
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
+  NAPI_ASSERT(env, argc == 1,
+    "Wrong number of arguments. Expects a single argument.");
+
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
+  NAPI_ASSERT(env, valuetype0 == napi_function,
+    "Wrong type of arguments. Expects a function as first argument.");
+
+  napi_valuetype valuetype1;
+  NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
+  NAPI_ASSERT(env, valuetype1 == napi_undefined,
+    "Additional arguments should be undefined.");
+
   napi_value argv[1];
   const char* str = "hello world";
   size_t str_len = strlen(str);
diff --git a/test/addons-napi/test_function/test_function.c b/test/addons-napi/test_function/test_function.c
index 928f99c184cb57..4ce0203e7232dd 100644
--- a/test/addons-napi/test_function/test_function.c
+++ b/test/addons-napi/test_function/test_function.c
@@ -12,7 +12,7 @@ napi_value Test(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
   NAPI_ASSERT(env, valuetype0 == napi_function,
-    "Wrong type of arguments. Expects a number as first argument.");
+    "Wrong type of arguments. Expects a function as first argument.");
 
   napi_value* argv = args + 1;
   argc = argc - 1;

From 184ffb5dfe3a91ee4a939fb2709393a885c987d8 Mon Sep 17 00:00:00 2001
From: Jason Ginchereau <jasongin@microsoft.com>
Date: Thu, 4 May 2017 15:24:44 -0700
Subject: [PATCH 034/183] n-api: Handle fatal exception in async callback

 - Create a handle scope before invoking the async completion
   callback, because it is basically always needed, easy for user
   code to forget, and this makes it more consistent with ordinary
   N-API function callbacks.

 - Check for an unhandled JS exception after invoking an async
   completion callback, and report it via `node::FatalException()`.

 - Add a corresponding test case for an exception in async callback.

Previously, any unhandled JS exception thrown from a
`napi_async_complete_callback` would be silently ignored. Among other
things this meant assertions in some test cases could be undetected.

PR-URL: https://github.com/nodejs/node/pull/12838
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 doc/api/n-api.md                          |  7 -------
 src/node_api.cc                           | 21 ++++++++++++++++++++-
 test/addons-napi/test_async/test.js       | 18 ++++++++++++++++++
 test/addons-napi/test_async/test_async.cc | 19 -------------------
 4 files changed, 38 insertions(+), 27 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index f9e47a7b8d32a0..bc0499e4d09447 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -2855,13 +2855,6 @@ will be invoked with a status value of `napi_cancelled`.
 The work should not be deleted before the `complete`
 callback invocation, even when it was cancelled.
 
-**Note:** As mentioned in the section on memory management, if
-the code to be run in the callbacks will create N-API values, then
-N-API handle scope functions must be used to create/destroy a
-`napi_handle_scope` such that the scope is active when
-objects can be created.
-
-
 ### napi_create_async_work
 <!-- YAML
 added: v8.0.0
diff --git a/src/node_api.cc b/src/node_api.cc
index 2f8409fc81627c..8600783523c7a5 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -2768,7 +2768,26 @@ class Work {
     Work* work = static_cast<Work*>(req->data);
 
     if (work->_complete != nullptr) {
-      work->_complete(work->_env, ConvertUVErrorCode(status), work->_data);
+      napi_env env = work->_env;
+
+      // Establish a handle scope here so that every callback doesn't have to.
+      // Also it is needed for the exception-handling below.
+      v8::HandleScope scope(env->isolate);
+
+      work->_complete(env, ConvertUVErrorCode(status), work->_data);
+
+      // Note: Don't access `work` after this point because it was
+      // likely deleted by the complete callback.
+
+      // If there was an unhandled exception in the complete callback,
+      // report it as a fatal exception. (There is no JavaScript on the
+      // callstack that can possibly handle it.)
+      if (!env->last_exception.IsEmpty()) {
+        v8::TryCatch try_catch;
+        env->isolate->ThrowException(
+          v8::Local<v8::Value>::New(env->isolate, env->last_exception));
+        node::FatalException(env->isolate, try_catch);
+      }
     }
   }
 
diff --git a/test/addons-napi/test_async/test.js b/test/addons-napi/test_async/test.js
index 2b4577624a371e..eda6963743ff6f 100644
--- a/test/addons-napi/test_async/test.js
+++ b/test/addons-napi/test_async/test.js
@@ -1,12 +1,30 @@
 'use strict';
 const common = require('../../common');
 const assert = require('assert');
+const child_process = require('child_process');
 const test_async = require(`./build/${common.buildType}/test_async`);
 
+const testException = 'test_async_cb_exception';
+
+// Exception thrown from async completion callback.
+// (Tested in a spawned process because the exception is fatal.)
+if (process.argv[2] === 'child') {
+  test_async.Test(1, common.mustCall(function(err, val) {
+    throw new Error(testException);
+  }));
+  return;
+}
+const p = child_process.spawnSync(
+  process.execPath, [ '--napi-modules', __filename, 'child' ]);
+assert.ifError(p.error);
+assert.ok(p.stderr.toString().includes(testException));
+
+// Successful async execution and completion callback.
 test_async.Test(5, common.mustCall(function(err, val) {
   assert.strictEqual(err, null);
   assert.strictEqual(val, 10);
   process.nextTick(common.mustCall());
 }));
 
+// Async work item cancellation with callback.
 test_async.TestCancel(common.mustCall());
diff --git a/test/addons-napi/test_async/test_async.cc b/test/addons-napi/test_async/test_async.cc
index 21245e9e835659..cc7bc334304323 100644
--- a/test/addons-napi/test_async/test_async.cc
+++ b/test/addons-napi/test_async/test_async.cc
@@ -20,22 +20,6 @@ typedef struct {
 carrier the_carrier;
 carrier async_carrier[MAX_CANCEL_THREADS];
 
-struct AutoHandleScope {
-  explicit AutoHandleScope(napi_env env)
-  : _env(env),
-  _scope(nullptr) {
-    napi_open_handle_scope(_env, &_scope);
-  }
-  ~AutoHandleScope() {
-    napi_close_handle_scope(_env, _scope);
-  }
- private:
-  AutoHandleScope() { }
-
-  napi_env _env;
-  napi_handle_scope _scope;
-};
-
 void Execute(napi_env env, void* data) {
 #if defined _WIN32
   Sleep(1000);
@@ -53,7 +37,6 @@ void Execute(napi_env env, void* data) {
 }
 
 void Complete(napi_env env, napi_status status, void* data) {
-  AutoHandleScope scope(env);
   carrier* c = static_cast<carrier*>(data);
 
   if (c != &the_carrier) {
@@ -116,13 +99,11 @@ napi_value Test(napi_env env, napi_callback_info info) {
 }
 
 void BusyCancelComplete(napi_env env, napi_status status, void* data) {
-  AutoHandleScope scope(env);
   carrier* c = static_cast<carrier*>(data);
   NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, c->_request));
 }
 
 void CancelComplete(napi_env env, napi_status status, void* data) {
-  AutoHandleScope scope(env);
   carrier* c = static_cast<carrier*>(data);
 
   if (status == napi_cancelled) {

From b69818d67fcfd784e54e518613c1e7f19da626c8 Mon Sep 17 00:00:00 2001
From: Michael Dawson <mdawson@devrus.com>
Date: Sun, 7 May 2017 19:46:11 -0400
Subject: [PATCH 035/183] doc: fix broken links in n-api doc
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- fix 2 broken links
- fix capitalization in description of
napi_create_array-with-length

PR-URL: https://github.com/nodejs/node/pull/12889
Reviewed-By: Sakthipriyan Vairamani <thechargingvolcano@gmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
Reviewed-By: MichaëZasso <targos@protonmail.com>
Reviewed-By: Gibson Fahnestock <gibfahn@gmail.com>
Reviewed-By: Hitesh Kanwathirtha <digitalinfinity@gmail.com>
---
 doc/api/n-api.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index bc0499e4d09447..7530c0b1b4f4d2 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -952,7 +952,7 @@ The Array's length property is set to the passed-in length parameter.
 However, the underlying buffer is not guaranteed to be pre-allocated by the VM
 when the array is created - that behavior is left to the underlying VM
 implementation.
-if the buffer must be a contiguous block of memory that can be
+If the buffer must be a contiguous block of memory that can be
 directly read and/or written via C, consider using
 [`napi_create_external_arraybuffer`][].
 
@@ -2958,13 +2958,13 @@ callback invocation, even when it was cancelled.
 [`napi_close_handle_scope`]: #n_api_napi_close_handle_scope
 [`napi_create_async_work`]: #n_api_napi_create_async_work
 [`napi_create_error`]: #n_api_napi_create_error
-[`napi_create_external_arraybuffer`][]: #n_api_napi_create_external_arraybuffer
+[`napi_create_external_arraybuffer`]: #n_api_napi_create_external_arraybuffer
 [`napi_create_range_error`]: #n_api_napi_create_range_error
 [`napi_create_reference`]: #n_api_napi_create_reference
 [`napi_create_type_error`]: #n_api_napi_create_type_error
 [`napi_define_class`]: #n_api_napi_define_class
 [`napi_delete_async_work`]: #n_api_napi_delete_async_work
-[`napi_define_class`][]: #n_api_napi_define_class
+[`napi_define_class`]: #n_api_napi_define_class
 [`napi_delete_reference`]: #n_api_napi_delete_reference
 [`napi_escape_handle`]: #n_api_napi_escape_handle
 [`napi_get_array_length`]: #n_api_napi_get_array_length

From 17d8b5524478549088ae096b74ff9e7d55a137d5 Mon Sep 17 00:00:00 2001
From: Michael Dawson <mdawson@devrus.com>
Date: Sun, 7 May 2017 19:40:58 -0400
Subject: [PATCH 036/183] test: improve n-api array func coverage

- add coverage for napi_has_element
- add coverage for napi_create_array_with_length

PR-URL: https://github.com/nodejs/node/pull/12890
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/addons-napi/test_array/test.js      | 22 +++++--
 test/addons-napi/test_array/test_array.c | 74 +++++++++++++++++++++---
 2 files changed, 82 insertions(+), 14 deletions(-)

diff --git a/test/addons-napi/test_array/test.js b/test/addons-napi/test_array/test.js
index c2759b007249e9..c1df4633b216fe 100644
--- a/test/addons-napi/test_array/test.js
+++ b/test/addons-napi/test_array/test.js
@@ -19,19 +19,31 @@ const array = [
   ]
 ];
 
-assert.strictEqual(test_array.Test(array, array.length + 1),
-                   'Index out of bound!');
+assert.throws(
+  () => {
+    test_array.TestGetElement(array, array.length + 1);
+  },
+  /^Error: assertion \(\(\(uint32_t\)index < length\)\) failed: Index out of bounds!$/
+);
 
 assert.throws(
   () => {
-    test_array.Test(array, -2);
+    test_array.TestGetElement(array, -2);
   },
-  /Invalid index\. Expects a positive integer\./
+  /^Error: assertion \(index >= 0\) failed: Invalid index\. Expects a positive integer\.$/
 );
 
 array.forEach(function(element, index) {
-  assert.strictEqual(test_array.Test(array, index), element);
+  assert.strictEqual(test_array.TestGetElement(array, index), element);
 });
 
 
 assert.deepStrictEqual(test_array.New(array), array);
+
+assert(test_array.TestHasElement(array, 0));
+assert.strictEqual(test_array.TestHasElement(array, array.length + 1), false);
+
+assert(test_array.NewWithLength(0) instanceof Array);
+assert(test_array.NewWithLength(1) instanceof Array);
+// check max allowed length for an array 2^32 -1
+assert(test_array.NewWithLength(4294967295) instanceof Array);
diff --git a/test/addons-napi/test_array/test_array.c b/test/addons-napi/test_array/test_array.c
index 3634a85e3cac7a..ed1380efc99cde 100644
--- a/test/addons-napi/test_array/test_array.c
+++ b/test/addons-napi/test_array/test_array.c
@@ -2,7 +2,7 @@
 #include <string.h>
 #include "../common.h"
 
-napi_value Test(napi_env env, napi_callback_info info) {
+napi_value TestGetElement(napi_env env, napi_callback_info info) {
   size_t argc = 2;
   napi_value args[2];
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
@@ -37,17 +37,49 @@ napi_value Test(napi_env env, napi_callback_info info) {
   uint32_t length;
   NAPI_CALL(env, napi_get_array_length(env, array, &length));
 
-  if ((uint32_t)index >= length) {
-    napi_value str;
-    const char* str_val = "Index out of bound!";
-    size_t str_len = strlen(str_val);
-    NAPI_CALL(env, napi_create_string_utf8(env, str_val, str_len, &str));
+  NAPI_ASSERT(env, ((uint32_t)index < length), "Index out of bounds!");
 
-    return str;
+  napi_value ret;
+  NAPI_CALL(env, napi_get_element(env, array, index, &ret));
+
+  return ret;
+}
+
+napi_value TestHasElement(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value args[2];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 2, "Wrong number of arguments");
+
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
+
+  NAPI_ASSERT(env, valuetype0 == napi_object,
+    "Wrong type of arguments. Expects an array as first argument.");
+
+  napi_valuetype valuetype1;
+  NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
+
+  NAPI_ASSERT(env, valuetype1 == napi_number,
+    "Wrong type of arguments. Expects an integer as second argument.");
+
+  napi_value array = args[0];
+  int32_t index;
+  NAPI_CALL(env, napi_get_value_int32(env, args[1], &index));
+
+  bool isarray;
+  NAPI_CALL(env, napi_is_array(env, array, &isarray));
+
+  if (!isarray) {
+    return NULL;
   }
 
+  bool has_element;
+  NAPI_CALL(env, napi_has_element(env, array, index, &has_element));
+
   napi_value ret;
-  NAPI_CALL(env, napi_get_element(env, array, index, &ret));
+  NAPI_CALL(env, napi_get_boolean(env, has_element, &ret));
 
   return ret;
 }
@@ -80,10 +112,34 @@ napi_value New(napi_env env, napi_callback_info info) {
   return ret;
 }
 
+napi_value NewWithLength(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
+
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
+
+  NAPI_ASSERT(env, valuetype0 == napi_number,
+    "Wrong type of arguments. Expects an integer the first argument.");
+
+  int32_t array_length;
+  NAPI_CALL(env, napi_get_value_int32(env, args[0], &array_length));
+
+  napi_value ret;
+  NAPI_CALL(env, napi_create_array_with_length(env, array_length, &ret));
+
+  return ret;
+}
+
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor descriptors[] = {
-    DECLARE_NAPI_PROPERTY("Test", Test),
+    DECLARE_NAPI_PROPERTY("TestGetElement", TestGetElement),
+    DECLARE_NAPI_PROPERTY("TestHasElement", TestHasElement),
     DECLARE_NAPI_PROPERTY("New", New),
+    DECLARE_NAPI_PROPERTY("NewWithLength", NewWithLength),
   };
 
   NAPI_CALL_RETURN_VOID(env, napi_define_properties(

From ce0e121381229bdf1adb7ca0ecd549d7d58dd860 Mon Sep 17 00:00:00 2001
From: Beth Griggs <Bethany.Griggs@uk.ibm.com>
Date: Mon, 8 May 2017 10:36:41 +0100
Subject: [PATCH 037/183] doc: clarify node.js addons are c++

PR-URL: https://github.com/nodejs/node/pull/12898
Fixes: https://github.com/nodejs/node/issues/7129
Reviewed-By: Sam Roberts <vieuxtech@gmail.com>
Reviewed-By: Sakthipriyan Vairamani <thechargingvolcano@gmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Gibson Fahnestock <gibfahn@gmail.com>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 doc/api/_toc.md   | 2 +-
 doc/api/addons.md | 6 +++---
 doc/api/n-api.md  | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/doc/api/_toc.md b/doc/api/_toc.md
index 034844110a1fe7..cdca642eeb9b93 100644
--- a/doc/api/_toc.md
+++ b/doc/api/_toc.md
@@ -7,7 +7,7 @@
 
 * [Assertion Testing](assert.html)
 * [Buffer](buffer.html)
-* [C/C++ Addons](addons.html)
+* [C++ Addons](addons.html)
 * [C/C++ Addons - N-API](n-api.html)
 * [Child Processes](child_process.html)
 * [Cluster](cluster.html)
diff --git a/doc/api/addons.md b/doc/api/addons.md
index d7ede4ca23ae22..4efc09b399e139 100644
--- a/doc/api/addons.md
+++ b/doc/api/addons.md
@@ -1,8 +1,8 @@
-# C/C++ Addons
+# C++ Addons
 
 <!--introduced_in=v0.10.0-->
 
-Node.js Addons are dynamically-linked shared objects, written in C or C++, that
+Node.js Addons are dynamically-linked shared objects, written in C++, that
 can be loaded into Node.js using the [`require()`][require] function, and used
 just as if they were an ordinary Node.js module. They are used primarily to
 provide an interface between JavaScript running in Node.js and C/C++ libraries.
@@ -28,7 +28,7 @@ involving knowledge of several components and APIs :
    off-loading work via libuv to non-blocking system operations, worker threads
    or a custom use of libuv's threads.
 
- - Internal Node.js libraries. Node.js itself exports a number of C/C++ APIs
+ - Internal Node.js libraries. Node.js itself exports a number of C++ APIs
    that Addons can use &mdash; the most important of which is the
    `node::ObjectWrap` class.
 
diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 7530c0b1b4f4d2..348f2ad04466bd 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -12,7 +12,7 @@ compiled for one version to run on later versions of Node.js without
 recompilation.
 
 Addons are built/packaged with the same approach/tools
-outlined in the section titled  [C/C++ Addons](addons.html).
+outlined in the section titled  [C++ Addons](addons.html).
 The only difference is the set of APIs that are used by the native code.
 Instead of using the V8 or [Native Abstractions for Node.js][] APIs,
 the functions available in the N-API are used.

From bdd1375155504accbd0e9780b959d79dc241fe33 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Wed, 10 May 2017 19:37:25 -0700
Subject: [PATCH 038/183] test: add common.mustCall() to NAPI exception test

Use `common.mustCall()` to confirm that function is invoked.

PR-URL: https://github.com/nodejs/node/pull/12959
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Sakthipriyan Vairamani <thechargingvolcano@gmail.com>
Reviewed-By: Gibson Fahnestock <gibfahn@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/addons-napi/test_exception/test.js | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/test/addons-napi/test_exception/test.js b/test/addons-napi/test_exception/test.js
index 94f9566a4b341f..ddd1195fa7234a 100644
--- a/test/addons-napi/test_exception/test.js
+++ b/test/addons-napi/test_exception/test.js
@@ -9,8 +9,6 @@ function throwTheError() {
 }
 let caughtError;
 
-const throwNoError = common.noop;
-
 // Test that the native side successfully captures the exception
 let returnedError = test_exception.returnException(throwTheError);
 assert.strictEqual(theError, returnedError,
@@ -34,13 +32,13 @@ assert.strictEqual(test_exception.wasPending(), true,
                    ' when it was allowed through');
 
 // Test that the native side does not capture a non-existing exception
-returnedError = test_exception.returnException(throwNoError);
+returnedError = test_exception.returnException(common.mustCall());
 assert.strictEqual(undefined, returnedError,
                    'Returned error is undefined when no exception is thrown');
 
 // Test that no exception appears that was not thrown by us
 try {
-  test_exception.allowException(throwNoError);
+  test_exception.allowException(common.mustCall());
 } catch (anError) {
   caughtError = anError;
 }

From ba2594e1cee76e228dab69431e0023ec178ad66e Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Thu, 11 May 2017 09:53:35 -0400
Subject: [PATCH 039/183] doc: clarify operation of napi_cancel_async_work

PR-URL: https://github.com/nodejs/node/pull/12974
Reviewed-By: Gibson Fahnestock <gibfahn@gmail.com>
Reviewed-By: Sakthipriyan Vairamani <thechargingvolcano@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
---
 doc/api/n-api.md | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 348f2ad04466bd..423e71859dea94 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -2931,11 +2931,12 @@ NAPI_EXTERN napi_status napi_cancel_async_work(napi_env env,
 
 Returns `napi_ok` if the API succeeded.
 
-This API cancels a previously allocated work, provided
-it has not yet been queued for execution. After this function is called
+This API cancels queued work if it has not yet
+been started.  If it has already started executing, it cannot be
+cancelled and `napi_generic_failure` will be returned. If successful,
 the `complete` callback will be invoked with a status value of
 `napi_cancelled`. The work should not be deleted before the `complete`
-callback invocation, even when it was cancelled.
+callback invocation, even if it has been successfully cancelled.
 
 
 [Aynchronous Operations]: #n_api_asynchronous_operations

From 67e0372e2a475d07dde58409d35a1b7326941903 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Fri, 12 May 2017 17:26:38 -0400
Subject: [PATCH 040/183] test: improve N-API test coverage

Add tests to cover functions that return globals

PR-URL: https://github.com/nodejs/node/pull/13006
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
---
 test/addons-napi/test_globals/binding.gyp    |  8 ++++++
 test/addons-napi/test_globals/test.js        |  8 ++++++
 test/addons-napi/test_globals/test_globals.c | 26 ++++++++++++++++++++
 3 files changed, 42 insertions(+)
 create mode 100644 test/addons-napi/test_globals/binding.gyp
 create mode 100644 test/addons-napi/test_globals/test.js
 create mode 100644 test/addons-napi/test_globals/test_globals.c

diff --git a/test/addons-napi/test_globals/binding.gyp b/test/addons-napi/test_globals/binding.gyp
new file mode 100644
index 00000000000000..0160dc72e18017
--- /dev/null
+++ b/test/addons-napi/test_globals/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_globals",
+      "sources": [ "test_globals.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_globals/test.js b/test/addons-napi/test_globals/test.js
new file mode 100644
index 00000000000000..a6e5f722cb9379
--- /dev/null
+++ b/test/addons-napi/test_globals/test.js
@@ -0,0 +1,8 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+
+const test_globals = require(`./build/${common.buildType}/test_globals`);
+
+assert.strictEqual(test_globals.getUndefined(), undefined);
+assert.strictEqual(test_globals.getNull(), null);
diff --git a/test/addons-napi/test_globals/test_globals.c b/test/addons-napi/test_globals/test_globals.c
new file mode 100644
index 00000000000000..709e42a2e0e6c8
--- /dev/null
+++ b/test/addons-napi/test_globals/test_globals.c
@@ -0,0 +1,26 @@
+#include <node_api.h>
+#include "../common.h"
+
+napi_value getNull(napi_env env, napi_callback_info info) {
+  napi_value result;
+  NAPI_CALL(env, napi_get_null(env, &result));
+  return result;
+}
+
+napi_value getUndefined(napi_env env, napi_callback_info info) {
+  napi_value result;
+  NAPI_CALL(env, napi_get_undefined(env, &result));
+  return result;
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_property_descriptor descriptors[] = {
+    DECLARE_NAPI_PROPERTY("getUndefined", getUndefined),
+    DECLARE_NAPI_PROPERTY("getNull", getNull),
+  };
+
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+}
+
+NAPI_MODULE(addon, Init)

From d572c9c262d5269ae785db20ff4f1502e90383ac Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Sat, 13 May 2017 17:36:23 +0200
Subject: [PATCH 041/183] n-api: remove compiler warning

`TryCatch` without an `Isolate*` argument is deprecated, so add one.

PR-URL: https://github.com/nodejs/node/pull/13014
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
Reviewed-By: Gibson Fahnestock <gibfahn@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
---
 src/node_api.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 8600783523c7a5..b0900d1acd12bb 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -2783,7 +2783,7 @@ class Work {
       // report it as a fatal exception. (There is no JavaScript on the
       // callstack that can possibly handle it.)
       if (!env->last_exception.IsEmpty()) {
-        v8::TryCatch try_catch;
+        v8::TryCatch try_catch(env->isolate);
         env->isolate->ThrowException(
           v8::Local<v8::Value>::New(env->isolate, env->last_exception));
         node::FatalException(env->isolate, try_catch);

From b10fe3e8bc28cedff58189552296c8be340ec348 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Mon, 15 May 2017 20:18:50 -0400
Subject: [PATCH 042/183] test: Improve N-API test coverage

- add coverage for napi_get_prototype
- add coverage for napi_strict_equals

PR-URL: https://github.com/nodejs/node/pull/13044
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
---
 test/addons-napi/test_general/binding.gyp    |  8 +++++
 test/addons-napi/test_general/test.js        | 32 +++++++++++++++++
 test/addons-napi/test_general/test_general.c | 38 ++++++++++++++++++++
 3 files changed, 78 insertions(+)
 create mode 100644 test/addons-napi/test_general/binding.gyp
 create mode 100644 test/addons-napi/test_general/test.js
 create mode 100644 test/addons-napi/test_general/test_general.c

diff --git a/test/addons-napi/test_general/binding.gyp b/test/addons-napi/test_general/binding.gyp
new file mode 100644
index 00000000000000..f8ef9f59613355
--- /dev/null
+++ b/test/addons-napi/test_general/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_general",
+      "sources": [ "test_general.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_general/test.js b/test/addons-napi/test_general/test.js
new file mode 100644
index 00000000000000..a2e57126ce8c22
--- /dev/null
+++ b/test/addons-napi/test_general/test.js
@@ -0,0 +1,32 @@
+'use strict';
+
+const common = require('../../common');
+const test_general = require(`./build/${common.buildType}/test_general`);
+const assert = require('assert');
+
+const val1 = '1';
+const val2 = 1;
+const val3 = 1;
+
+class BaseClass {
+}
+
+class ExtendedClass extends BaseClass {
+}
+
+const baseObject = new BaseClass();
+const extendedObject = new ExtendedClass();
+
+// test napi_strict_equals
+assert.ok(test_general.testStrictEquals(val1, val1));
+assert.strictEqual(test_general.testStrictEquals(val1, val2), false);
+assert.ok(test_general.testStrictEquals(val2, val3));
+
+// test napi_get_prototype
+assert.strictEqual(test_general.testGetPrototype(baseObject),
+                   Object.getPrototypeOf(baseObject));
+assert.strictEqual(test_general.testGetPrototype(extendedObject),
+                   Object.getPrototypeOf(extendedObject));
+assert.ok(test_general.testGetPrototype(baseObject) !==
+          test_general.testGetPrototype(extendedObject),
+          'Prototypes for base and extended should be different');
diff --git a/test/addons-napi/test_general/test_general.c b/test/addons-napi/test_general/test_general.c
new file mode 100644
index 00000000000000..17911b36253df1
--- /dev/null
+++ b/test/addons-napi/test_general/test_general.c
@@ -0,0 +1,38 @@
+#include <node_api.h>
+#include "../common.h"
+
+napi_value testStrictEquals(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value args[2];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  bool bool_result;
+  napi_value result;
+  NAPI_CALL(env, napi_strict_equals(env, args[0], args[1], &bool_result));
+  NAPI_CALL(env, napi_get_boolean(env, bool_result, &result));
+
+  return result;
+}
+
+napi_value testGetPrototype(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  napi_value result;
+  NAPI_CALL(env, napi_get_prototype(env, args[0], &result));
+
+  return result;
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_property_descriptor descriptors[] = {
+    DECLARE_NAPI_PROPERTY("testStrictEquals", testStrictEquals),
+    DECLARE_NAPI_PROPERTY("testGetPrototype", testGetPrototype),
+  };
+
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+}
+
+NAPI_MODULE(addon, Init)

From 726d5849777a155dcc788fbbc4a993da7c43fe90 Mon Sep 17 00:00:00 2001
From: Jason Ginchereau <jasongin@microsoft.com>
Date: Wed, 17 May 2017 16:56:37 -0700
Subject: [PATCH 043/183] n-api: Retain last code when getting error info

Unlike most N-API functions, `napi_get_last_error_info()` should not
clear the last error code when successful, because a pointer to (not
a copy of) the error info structure is returned via an out parameter.

PR-URL: https://github.com/nodejs/node/pull/13087
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 src/node_api.cc                                       | 2 +-
 test/addons-napi/test_napi_status/test_napi_status.cc | 8 ++++++++
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index b0900d1acd12bb..976bf15f3ca423 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -757,7 +757,7 @@ napi_status napi_get_last_error_info(napi_env env,
       error_messages[env->last_error.error_code];
 
   *result = &(env->last_error);
-  return napi_clear_last_error(env);
+  return napi_ok;
 }
 
 napi_status napi_create_function(napi_env env,
diff --git a/test/addons-napi/test_napi_status/test_napi_status.cc b/test/addons-napi/test_napi_status/test_napi_status.cc
index 9046feffd4a15d..9e340aa46e106c 100644
--- a/test/addons-napi/test_napi_status/test_napi_status.cc
+++ b/test/addons-napi/test_napi_status/test_napi_status.cc
@@ -10,6 +10,14 @@ napi_value createNapiError(napi_env env, napi_callback_info info) {
 
   NAPI_ASSERT(env, status != napi_ok, "Failed to produce error condition");
 
+  const napi_extended_error_info *error_info = 0;
+  NAPI_CALL(env, napi_get_last_error_info(env, &error_info));
+
+  NAPI_ASSERT(env, error_info->error_code == status,
+    "Last error info code should match last status");
+  NAPI_ASSERT(env, error_info->error_message,
+    "Last error info message should not be null");
+
   return nullptr;
 }
 

From f7232ad330cffe13f80f130883f1f5ad9a2cba2c Mon Sep 17 00:00:00 2001
From: Michael Dawson <mdawson@devrus.com>
Date: Wed, 17 May 2017 17:16:37 -0400
Subject: [PATCH 044/183] doc: add reference to node_api.h in docs

Realized that we don't actually point people to the file to
include in order to access N-API functions.  Add that.

PR-URL: https://github.com/nodejs/node/pull/13084
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Gibson Fahnestock <gibfahn@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 doc/api/n-api.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 423e71859dea94..de841331aba0ad 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -52,6 +52,14 @@ for the N-API C based functions exported by Node.js. These wrappers are not
 part of N-API, nor will they be maintained as part of Node.js. One such
 example is: [node-api](https://github.com/nodejs/node-api).
 
+In order to use the N-API functions, include the file
+[node_api.h](https://github.com/nodejs/node/blob/master/src/node_api.h)
+which is located in the src directory in the node development tree.
+For example:
+```C
+#include <node_api.h>
+```
+
 ## Basic N-API Data Types
 
 N-API exposes the following fundamental datatypes as abstractions that are

From 2e48f585cb47de0add787f623a353c156eb25b2f Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Fri, 19 May 2017 17:34:11 -0400
Subject: [PATCH 045/183] doc: fix title/function name mismatch

Fix mismatch in title for napi_get_value_string_utf16

Fixes: https://github.com/nodejs/abi-stable-node/issues/243
PR-URL: https://github.com/nodejs/node/pull/13123
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Gibson Fahnestock <gibfahn@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 doc/api/n-api.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index de841331aba0ad..d3efd09ab15ec0 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -1590,7 +1590,7 @@ x is passed in it returns `napi_string_expected`.
 
 This API returns the UTF8-encoded string corresponding the value passed in.
 
-#### *napi_get_value_string_utf16_length*
+#### *napi_get_value_string_utf16*
 <!-- YAML
 added: v8.0.0
 -->

From 4d730bed50152a5b4be7dfd2374f1d6ec5feebab Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Fri, 19 May 2017 18:18:54 -0400
Subject: [PATCH 046/183] test: increase n-api constructor coverage

Add tests to validate that properties marked as static
are available through the class as opposed to instances

PR-URL: https://github.com/nodejs/node/pull/13124
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Hitesh Kanwathirtha <digitalinfinity@gmail.com>
---
 test/addons-napi/test_constructor/test.js        |  5 +++++
 .../test_constructor/test_constructor.c          | 16 ++++++++++++++++
 2 files changed, 21 insertions(+)

diff --git a/test/addons-napi/test_constructor/test.js b/test/addons-napi/test_constructor/test.js
index 26083db7a28a21..75c7b3678306e4 100644
--- a/test/addons-napi/test_constructor/test.js
+++ b/test/addons-napi/test_constructor/test.js
@@ -40,3 +40,8 @@ test_object.readwriteAccessor2 = 2;
 assert.strictEqual(test_object.readwriteAccessor2, 2);
 assert.strictEqual(test_object.readonlyAccessor2, 2);
 assert.throws(() => { test_object.readonlyAccessor2 = 3; }, TypeError);
+
+// validate that static properties are on the class as opposed
+// to the instance
+assert.strictEqual(TestConstructor.staticReadonlyAccessor1, 10);
+assert.strictEqual(test_object.staticReadonlyAccessor1, undefined);
diff --git a/test/addons-napi/test_constructor/test_constructor.c b/test/addons-napi/test_constructor/test_constructor.c
index 0a73010d72f115..220d564753ca10 100644
--- a/test/addons-napi/test_constructor/test_constructor.c
+++ b/test/addons-napi/test_constructor/test_constructor.c
@@ -2,6 +2,7 @@
 #include "../common.h"
 
 static double value_ = 1;
+static double static_value_ = 10;
 napi_ref constructor_;
 
 napi_value GetValue(napi_env env, napi_callback_info info) {
@@ -45,6 +46,19 @@ napi_value New(napi_env env, napi_callback_info info) {
   return _this;
 }
 
+napi_value GetStaticValue(napi_env env, napi_callback_info info) {
+  size_t argc = 0;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, NULL, NULL, NULL));
+
+  NAPI_ASSERT(env, argc == 0, "Wrong number of arguments");
+
+  napi_value number;
+  NAPI_CALL(env, napi_create_number(env, static_value_, &number));
+
+  return number;
+}
+
+
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_value number;
   NAPI_CALL_RETURN_VOID(env, napi_create_number(env, value_, &number));
@@ -58,6 +72,8 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     { "readwriteAccessor2", 0, 0, GetValue, SetValue, 0, napi_writable, 0},
     { "readonlyAccessor1", 0, 0, GetValue, NULL, 0, napi_default, 0},
     { "readonlyAccessor2", 0, 0, GetValue, NULL, 0, napi_writable, 0},
+    { "staticReadonlyAccessor1", 0, 0, GetStaticValue, NULL, 0,
+        napi_default | napi_static, 0},
   };
 
   napi_value cons;

From 278ba33f70beef76d5b995bfa5a95ab3e357f6de Mon Sep 17 00:00:00 2001
From: Daniel Bevenius <daniel.bevenius@gmail.com>
Date: Wed, 24 May 2017 12:49:07 +0200
Subject: [PATCH 047/183] src: correct endif comment SRC_NODE_API_H__

Really minor but I could not find an open PR for anything n-api where
this could be changed, so creating this so that it is not forgotten.

PR-URL: https://github.com/nodejs/node/pull/13190
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Michael Dawson <mhdawson@ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 src/node_api.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/node_api.h b/src/node_api.h
index 29c5c513f72f59..5a95c030a35272 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -480,4 +480,4 @@ NAPI_EXTERN napi_status napi_cancel_async_work(napi_env env,
 
 EXTERN_C_END
 
-#endif  // SRC_NODE_API_H__
+#endif  // SRC_NODE_API_H_

From 54bd4b531f79ab8186c186e954d1f4e8f4347dff Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Tue, 23 May 2017 17:26:37 -0400
Subject: [PATCH 048/183] test: add coverage for napi_has_named_property

Add test to cover napi_has_named_property

PR-URL: https://github.com/nodejs/node/pull/13178
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
---
 test/addons-napi/test_properties/test.js      |  6 +++++
 .../test_properties/test_properties.c         | 23 +++++++++++++++++++
 2 files changed, 29 insertions(+)

diff --git a/test/addons-napi/test_properties/test.js b/test/addons-napi/test_properties/test.js
index a8127a27860eb3..0f37af81b7ffad 100644
--- a/test/addons-napi/test_properties/test.js
+++ b/test/addons-napi/test_properties/test.js
@@ -39,3 +39,9 @@ test_object.readwriteAccessor2 = 2;
 assert.strictEqual(test_object.readwriteAccessor2, 2);
 assert.strictEqual(test_object.readonlyAccessor2, 2);
 assert.throws(() => { test_object.readonlyAccessor2 = 3; }, TypeError);
+
+assert.strictEqual(test_object.hasNamedProperty(test_object, 'echo'), true);
+assert.strictEqual(test_object.hasNamedProperty(test_object, 'hiddenValue'),
+                   true);
+assert.strictEqual(test_object.hasNamedProperty(test_object, 'doesnotexist'),
+                   false);
diff --git a/test/addons-napi/test_properties/test_properties.c b/test/addons-napi/test_properties/test_properties.c
index 67e6b1a0d5ed0a..575d750a7d936b 100644
--- a/test/addons-napi/test_properties/test_properties.c
+++ b/test/addons-napi/test_properties/test_properties.c
@@ -37,6 +37,28 @@ napi_value Echo(napi_env env, napi_callback_info info) {
   return args[0];
 }
 
+napi_value HasNamedProperty(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value args[2];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc == 2, "Wrong number of arguments");
+
+  // Extract the name of the property to check
+  char buffer[128];
+  size_t copied;
+  NAPI_CALL(env,
+    napi_get_value_string_utf8(env, args[1], buffer, sizeof(buffer), &copied));
+
+  // do the check and create the boolean return value
+  bool value;
+  napi_value result;
+  NAPI_CALL(env, napi_has_named_property(env, args[0], buffer, &value));
+  NAPI_CALL(env, napi_get_boolean(env, value, &result));
+
+  return result;
+}
+
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_value number;
   NAPI_CALL_RETURN_VOID(env, napi_create_number(env, value_, &number));
@@ -50,6 +72,7 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     { "readwriteAccessor2", 0, 0, GetValue, SetValue, 0, napi_writable, 0},
     { "readonlyAccessor1", 0, 0, GetValue, NULL, 0, napi_default, 0},
     { "readonlyAccessor2", 0, 0, GetValue, NULL, 0, napi_writable, 0},
+    { "hasNamedProperty", 0, HasNamedProperty, 0, 0, 0, napi_default, 0 },
   };
 
   NAPI_CALL_RETURN_VOID(env, napi_define_properties(

From 5c0c021a4b7a27657aff8ef2c560574a37eeff81 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Wed, 24 May 2017 16:58:03 -0400
Subject: [PATCH 049/183] n-api: add napi_get_version

Add napi_get_version function so that addons can
query the level of N-API supported.

PR-URL: https://github.com/nodejs/node/pull/13207
Fixes: https://github.com/nodejs/abi-stable-node/issues/231
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
---
 doc/api/n-api.md                             | 29 ++++++++++++++++++++
 src/node_api.cc                              |  9 ++++++
 src/node_api.h                               |  4 +++
 test/addons-napi/test_general/test.js        |  4 +++
 test/addons-napi/test_general/test_general.c |  9 ++++++
 5 files changed, 55 insertions(+)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index d3efd09ab15ec0..e151a7357fbb58 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -2946,6 +2946,35 @@ the `complete` callback will be invoked with a status value of
 `napi_cancelled`. The work should not be deleted before the `complete`
 callback invocation, even if it has been successfully cancelled.
 
+## Version Management
+
+### napi_get_version
+<!-- YAML
+added: REPLACEME
+-->
+```C
+NAPI_EXTERN napi_status napi_get_version(napi_env env,
+                                         uint32_t* result);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[out] result`: The highest version of N-API supported.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns the highest N-API version supported by the
+Node.js runtime.  N-API is planned to be additive such that
+newer releases of Node.js may support additional API functions.
+In order to allow an addon to use a newer function when running with
+versions of Node.js that support it, while providing
+fallback behavior when running with Node.js versions that don't
+support it:
+
+* Call `napi_get_version()` to determine if the API is available.
+* If available, dynamically load a pointer to the function using `uv_dlsym()`.
+* Use the dynamically loaded pointer to invoke the function.
+* If the function is not available, provide an alternate implementation
+  that does not use the function.
 
 [Aynchronous Operations]: #n_api_asynchronous_operations
 [Basic N-API Data Types]: #n_api_basic_n_api_data_types
diff --git a/src/node_api.cc b/src/node_api.cc
index 976bf15f3ca423..7a485283bbb13d 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -20,6 +20,8 @@
 #include "env-inl.h"
 #include "node_api_backport.h"
 
+#define NAPI_VERSION  1
+
 static
 napi_status napi_set_last_error(napi_env env, napi_status error_code,
                                 uint32_t engine_error_code = 0,
@@ -2715,6 +2717,13 @@ napi_status napi_get_typedarray_info(napi_env env,
   return napi_clear_last_error(env);
 }
 
+napi_status napi_get_version(napi_env env, uint32_t* result) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
+  *result = NAPI_VERSION;
+  return napi_clear_last_error(env);
+}
+
 namespace uvimpl {
 
 static napi_status ConvertUVErrorCode(int code) {
diff --git a/src/node_api.h b/src/node_api.h
index 5a95c030a35272..a1840943602ce3 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -478,6 +478,10 @@ NAPI_EXTERN napi_status napi_queue_async_work(napi_env env,
 NAPI_EXTERN napi_status napi_cancel_async_work(napi_env env,
                                                napi_async_work work);
 
+
+// version management
+NAPI_EXTERN napi_status napi_get_version(napi_env env, uint32_t* result);
+
 EXTERN_C_END
 
 #endif  // SRC_NODE_API_H_
diff --git a/test/addons-napi/test_general/test.js b/test/addons-napi/test_general/test.js
index a2e57126ce8c22..614cf0f4f0e7c4 100644
--- a/test/addons-napi/test_general/test.js
+++ b/test/addons-napi/test_general/test.js
@@ -30,3 +30,7 @@ assert.strictEqual(test_general.testGetPrototype(extendedObject),
 assert.ok(test_general.testGetPrototype(baseObject) !==
           test_general.testGetPrototype(extendedObject),
           'Prototypes for base and extended should be different');
+
+// test version management funcitons
+// expected version is currently 1
+assert.strictEqual(test_general.testGetVersion(), 1);
diff --git a/test/addons-napi/test_general/test_general.c b/test/addons-napi/test_general/test_general.c
index 17911b36253df1..585a3bf2b3ff0d 100644
--- a/test/addons-napi/test_general/test_general.c
+++ b/test/addons-napi/test_general/test_general.c
@@ -25,10 +25,19 @@ napi_value testGetPrototype(napi_env env, napi_callback_info info) {
   return result;
 }
 
+napi_value testGetVersion(napi_env env, napi_callback_info info) {
+  uint32_t version;
+  napi_value result;
+  NAPI_CALL(env, napi_get_version(env, &version));
+  NAPI_CALL(env ,napi_create_number(env, version, &result));
+  return result;
+}
+
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("testStrictEquals", testStrictEquals),
     DECLARE_NAPI_PROPERTY("testGetPrototype", testGetPrototype),
+    DECLARE_NAPI_PROPERTY("testGetVersion", testGetVersion),
   };
 
   NAPI_CALL_RETURN_VOID(env, napi_define_properties(

From 5c19e28bcfd4721c119b40b8178c12a489d52cfc Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Fri, 26 May 2017 13:24:23 -0400
Subject: [PATCH 050/183] test: improve n-api coverage for typed arrays

Add testing for all types of typed arrays.
Add testing for napi_is_arraybuffer.

PR-URL: https://github.com/nodejs/node/pull/13244
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Kunal Pathak <kunal.pathak@microsoft.com>
Reviewed-By: Hitesh Kanwathirtha <digitalinfinity@gmail.com>
---
 test/addons-napi/test_typedarray/test.js      | 20 ++++++++
 .../test_typedarray/test_typedarray.c         | 48 +++++++++++++++++++
 2 files changed, 68 insertions(+)

diff --git a/test/addons-napi/test_typedarray/test.js b/test/addons-napi/test_typedarray/test.js
index cc1fcbe3566da3..dcb7d76442f608 100644
--- a/test/addons-napi/test_typedarray/test.js
+++ b/test/addons-napi/test_typedarray/test.js
@@ -37,3 +37,23 @@ assert.strictEqual(externalResult.length, 3);
 assert.strictEqual(externalResult[0], 0);
 assert.strictEqual(externalResult[1], 1);
 assert.strictEqual(externalResult[2], 2);
+
+// validate creation of all kinds of TypedArrays
+const buffer = new ArrayBuffer(128);
+const arrayTypes = [ Int8Array, Uint8Array, Uint8ClampedArray, Int16Array,
+                     Uint16Array, Int32Array, Uint32Array, Float32Array,
+                     Float64Array ];
+
+arrayTypes.forEach((currentType, key) => {
+  const template = Reflect.construct(currentType, buffer);
+  const theArray = test_typedarray.CreateTypedArray(template, buffer);
+
+  assert.ok(theArray instanceof currentType,
+            'Type of new array should match that of the template');
+  assert.notStrictEqual(theArray,
+                        template,
+                        'the new array should not be a copy of the template');
+  assert.strictEqual(theArray.buffer,
+                     buffer,
+                     'Buffer for array should match the one passed in');
+});
diff --git a/test/addons-napi/test_typedarray/test_typedarray.c b/test/addons-napi/test_typedarray/test_typedarray.c
index d77945486518a2..4194492cae8b3a 100644
--- a/test/addons-napi/test_typedarray/test_typedarray.c
+++ b/test/addons-napi/test_typedarray/test_typedarray.c
@@ -95,10 +95,58 @@ napi_value External(napi_env env, napi_callback_info info) {
   return output_array;
 }
 
+napi_value CreateTypedArray(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value args[2];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc == 2, "Wrong number of arguments");
+
+  napi_value input_array = args[0];
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, input_array, &valuetype0));
+
+  NAPI_ASSERT(env, valuetype0 == napi_object,
+    "Wrong type of argments. Expects a typed array as first argument.");
+
+  bool is_typedarray;
+  NAPI_CALL(env, napi_is_typedarray(env, input_array, &is_typedarray));
+
+  NAPI_ASSERT(env, is_typedarray,
+    "Wrong type of argments. Expects a typed array as first argument.");
+
+  napi_valuetype valuetype1;
+  napi_value input_buffer = args[1];
+  NAPI_CALL(env, napi_typeof(env, input_buffer, &valuetype1));
+
+  NAPI_ASSERT(env, valuetype1 == napi_object,
+    "Wrong type of argments. Expects an array buffer as second argument.");
+
+  bool is_arraybuffer;
+  NAPI_CALL(env, napi_is_arraybuffer(env, input_buffer, &is_arraybuffer));
+
+  NAPI_ASSERT(env, is_arraybuffer,
+    "Wrong type of argments. Expects an array buffer as second argument.");
+
+  napi_typedarray_type type;
+  napi_value in_array_buffer;
+  size_t byte_offset;
+  size_t length;
+  NAPI_CALL(env, napi_get_typedarray_info(
+    env, input_array, &type, &length, NULL, &in_array_buffer, &byte_offset));
+
+  napi_value output_array;
+  NAPI_CALL(env, napi_create_typedarray(
+      env, type, length, input_buffer, byte_offset, &output_array));
+
+  return output_array;
+}
+
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("Multiply", Multiply),
     DECLARE_NAPI_PROPERTY("External", External),
+    DECLARE_NAPI_PROPERTY("CreateTypedArray", CreateTypedArray),
   };
 
   NAPI_CALL_RETURN_VOID(env, napi_define_properties(

From 8653a1bad4bea81504bf49f8c36d25831e6587e4 Mon Sep 17 00:00:00 2001
From: Jason Ginchereau <jasongin@microsoft.com>
Date: Thu, 18 May 2017 15:29:49 -0700
Subject: [PATCH 051/183] test: Make N-API weak-ref GC tests asynchronous

One of the N-API weak-reference test cases already had to be made
asynchronous to handle different behavior in a newer V8 version:
https://github.com/nodejs/node/pull/12864
When porting N-API to Node-ChakraCore, we found more of the test
cases needed similar treatment:
https://github.com/nodejs/node-chakracore/issues/246 So to make
thes tests more robust (and avoid having differences in the test code
for Node-ChakraCore), I am refactoring the tests in this file to
insert a `setImmedate()` callback before every call to `gc()` and
assertions about the effects of the GC.

PR-URL: https://github.com/nodejs/node/pull/13121
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 test/addons-napi/test_reference/test.js | 168 ++++++++++++++----------
 1 file changed, 99 insertions(+), 69 deletions(-)

diff --git a/test/addons-napi/test_reference/test.js b/test/addons-napi/test_reference/test.js
index 30effe7eec0922..aaf5531f39e1f3 100644
--- a/test/addons-napi/test_reference/test.js
+++ b/test/addons-napi/test_reference/test.js
@@ -11,80 +11,110 @@ const test_reference = require(`./build/${common.buildType}/test_reference`);
 // of a finalizer callback increments the finalizeCount property.
 assert.strictEqual(test_reference.finalizeCount, 0);
 
-{
-  // External value without a finalizer
-  let value = test_reference.createExternal();
-  assert.strictEqual(test_reference.finalizeCount, 0);
-  assert.strictEqual(typeof value, 'object');
-  test_reference.checkExternal(value);
-  value = null;
-  global.gc();
-  assert.strictEqual(test_reference.finalizeCount, 0);
+// Run each test function in sequence,
+// with an async delay and GC call between each.
+function runTests(i, title, tests) {
+  if (tests[i]) {
+    if (typeof tests[i] === 'string') {
+      title = tests[i];
+      runTests(i + 1, title, tests);
+    } else {
+      try {
+        tests[i]();
+      } catch (e) {
+        console.error('Test failed: ' + title);
+        throw e;
+      }
+      setImmediate(() => {
+        global.gc();
+        runTests(i + 1, title, tests);
+      });
+    }
+  }
 }
+runTests(0, undefined, [
 
-{
-  // External value with a finalizer
-  let value = test_reference.createExternalWithFinalize();
-  assert.strictEqual(test_reference.finalizeCount, 0);
-  assert.strictEqual(typeof value, 'object');
-  test_reference.checkExternal(value);
-  value = null;
-  global.gc();
-  assert.strictEqual(test_reference.finalizeCount, 1);
-}
-
-{
-  // Strong reference
-  let value = test_reference.createExternalWithFinalize();
-  assert.strictEqual(test_reference.finalizeCount, 0);
-  test_reference.createReference(value, 1);
-  assert.strictEqual(test_reference.referenceValue, value);
-  value = null;
-  global.gc(); // Value should NOT be GC'd because there is a strong ref
-  assert.strictEqual(test_reference.finalizeCount, 0);
-  test_reference.deleteReference();
-  global.gc(); // Value should be GC'd because the strong ref was deleted
-  assert.strictEqual(test_reference.finalizeCount, 1);
-}
-
-{
-  // Strong reference, increment then decrement to weak reference
-  let value = test_reference.createExternalWithFinalize();
-  assert.strictEqual(test_reference.finalizeCount, 0);
-  test_reference.createReference(value, 1);
-  value = null;
-  global.gc(); // Value should NOT be GC'd because there is a strong ref
-  assert.strictEqual(test_reference.finalizeCount, 0);
+  'External value without a finalizer',
+  () => {
+    const value = test_reference.createExternal();
+    assert.strictEqual(test_reference.finalizeCount, 0);
+    assert.strictEqual(typeof value, 'object');
+    test_reference.checkExternal(value);
+  },
+  () => {
+    assert.strictEqual(test_reference.finalizeCount, 0);
+  },
 
-  assert.strictEqual(test_reference.incrementRefcount(), 2);
-  global.gc(); // Value should NOT be GC'd because there is a strong ref
-  assert.strictEqual(test_reference.finalizeCount, 0);
-
-  assert.strictEqual(test_reference.decrementRefcount(), 1);
-  global.gc(); // Value should NOT be GC'd because there is a strong ref
-  assert.strictEqual(test_reference.finalizeCount, 0);
+  'External value with a finalizer',
+  () => {
+    const value = test_reference.createExternalWithFinalize();
+    assert.strictEqual(test_reference.finalizeCount, 0);
+    assert.strictEqual(typeof value, 'object');
+    test_reference.checkExternal(value);
+  },
+  () => {
+    assert.strictEqual(test_reference.finalizeCount, 1);
+  },
 
-  assert.strictEqual(test_reference.decrementRefcount(), 0);
-  global.gc(); // Value should be GC'd because the ref is now weak!
-  assert.strictEqual(test_reference.finalizeCount, 1);
+  'Weak reference',
+  () => {
+    const value = test_reference.createExternalWithFinalize();
+    assert.strictEqual(test_reference.finalizeCount, 0);
+    test_reference.createReference(value, 0);
+    assert.strictEqual(test_reference.referenceValue, value);
+  },
+  () => {
+    // Value should be GC'd because there is only a weak ref
+    assert.strictEqual(test_reference.referenceValue, undefined);
+    assert.strictEqual(test_reference.finalizeCount, 1);
+    test_reference.deleteReference();
+  },
 
-  test_reference.deleteReference();
-  global.gc(); // Value was already GC'd
-  assert.strictEqual(test_reference.finalizeCount, 1);
-}
+  'Strong reference',
+  () => {
+    const value = test_reference.createExternalWithFinalize();
+    assert.strictEqual(test_reference.finalizeCount, 0);
+    test_reference.createReference(value, 1);
+    assert.strictEqual(test_reference.referenceValue, value);
+  },
+  () => {
+    // Value should NOT be GC'd because there is a strong ref
+    assert.strictEqual(test_reference.finalizeCount, 0);
+    test_reference.deleteReference();
+  },
+  () => {
+    // Value should be GC'd because the strong ref was deleted
+    assert.strictEqual(test_reference.finalizeCount, 1);
+  },
 
-{
-  // Weak reference
-  let value = test_reference.createExternalWithFinalize();
-  assert.strictEqual(test_reference.finalizeCount, 0);
-  test_reference.createReference(value, 0);
-  assert.strictEqual(test_reference.referenceValue, value);
-  value = null;
-  setImmediate(common.mustCall(() => {
-    // This test only works if gc() is called from an immediate callback.
-    global.gc(); // Value should be GC'd because there is only a weak ref
-    assert.strictEqual(test_reference.referenceValue, undefined);
+  'Strong reference, increment then decrement to weak reference',
+  () => {
+    const value = test_reference.createExternalWithFinalize();
+    assert.strictEqual(test_reference.finalizeCount, 0);
+    test_reference.createReference(value, 1);
+  },
+  () => {
+    // Value should NOT be GC'd because there is a strong ref
+    assert.strictEqual(test_reference.finalizeCount, 0);
+    assert.strictEqual(test_reference.incrementRefcount(), 2);
+  },
+  () => {
+    // Value should NOT be GC'd because there is a strong ref
+    assert.strictEqual(test_reference.finalizeCount, 0);
+    assert.strictEqual(test_reference.decrementRefcount(), 1);
+  },
+  () => {
+    // Value should NOT be GC'd because there is a strong ref
+    assert.strictEqual(test_reference.finalizeCount, 0);
+    assert.strictEqual(test_reference.decrementRefcount(), 0);
+  },
+  () => {
+    // Value should be GC'd because the ref is now weak!
     assert.strictEqual(test_reference.finalizeCount, 1);
     test_reference.deleteReference();
-  }));
-}
+  },
+  () => {
+    // Value was already GC'd
+    assert.strictEqual(test_reference.finalizeCount, 1);
+  },
+]);

From 897bac2d0db143c351050ae97662049c56bbf4ee Mon Sep 17 00:00:00 2001
From: JongChan Choi <disjukr@naver.com>
Date: Wed, 31 May 2017 14:04:14 +0900
Subject: [PATCH 052/183] doc: fix typo in n-api.md

PR-URL: https://github.com/nodejs/node/pull/13323
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 doc/api/n-api.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index e151a7357fbb58..7da9e5171664a9 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -530,7 +530,7 @@ Taking the earlier example, adding calls to [`napi_open_handle_scope`][] and
 is valid throughout the execution of the loop:
 
 ```C
-for (int i = 0; i < 1000000; i++) {napi_
+for (int i = 0; i < 1000000; i++) {
   napi_handle_scope scope;
   napi_status status = napi_open_handle_scope(env, &scope);
   if (status != napi_ok) {

From 224958164f747349321895ac83aa043a06abec9b Mon Sep 17 00:00:00 2001
From: Jason Ginchereau <jasongin@microsoft.com>
Date: Thu, 25 May 2017 17:05:21 -0700
Subject: [PATCH 053/183] n-api: enable napi_wrap() to work with any object

Previously, napi_wrap() would only work with objects created from a
constructor returned by napi_define_class(). While the N-API team
was aware of this limitation, it was not clearly documented and is
likely to cause confusion anyway. It's much simpler if addons are
allowed to use any JS object. Also, the specific behavior of the
limitation is difficult to reimplement on other VMs that work
differently from V8.

V8 requires object internal fields to be declared on the object
prototype (which napi_define_class() used to do). Since it's too
late to modify the object prototype by the time napi_wrap() is
called, napi_wrap() now inserts a new object (with the internal
field) into the supplied object's prototype chain. Then it can be
retrieved from there later by napi_unwrap().

This change also includes improvements to the documentation for
napi_create_external(), partly to explain how it is different from
napi_wrap().

PR-URL: https://github.com/nodejs/node/pull/13250
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 doc/api/n-api.md                           | 57 ++++++++-----
 src/node_api.cc                            | 42 ++++++----
 test/addons-napi/test_object/test.js       | 98 +++++++++++++++-------
 test/addons-napi/test_object/test_object.c | 27 ++++++
 4 files changed, 159 insertions(+), 65 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 7da9e5171664a9..ab90cf05f4750d 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -1059,20 +1059,24 @@ napi_status napi_create_external(napi_env env,
 ```
 
 - `[in] env`: The environment that the API is invoked under.
-- `[in] data`: Raw pointer to the external data being wrapped.
-- `[in] finalize_cb`: Optional callback to call when the wrapped object
+- `[in] data`: Raw pointer to the external data.
+- `[in] finalize_cb`: Optional callback to call when the external value
 is being collected.
 - `[in] finalize_hint`: Optional hint to pass to the finalize callback
 during collection.
-- `[out] result`: A `napi_value` representing an external object.
+- `[out] result`: A `napi_value` representing an external value.
 
 Returns `napi_ok` if the API succeeded.
 
-This API allocates a JavaScript object with external data attached to it.
-This is used to wrap native objects and project them into JavaScript.
-The API allows the caller to pass in a finalize callback, in case the
-underlying native resource needs to be cleaned up when the wrapper
-JavaScript object gets collected.
+This API allocates a JavaScript value with external data attached to it. This
+is used to pass external data through JavaScript code, so it can be retrieved
+later by native code. The API allows the caller to pass in a finalize callback,
+in case the underlying native resource needs to be cleaned up when the external
+JavaScript value gets collected.
+
+*Note*: The created value is not an object, and therefore does not support
+additional properties. It is considered a distinct value type: calling
+`napi_typeof()` with an external value yields `napi_external`.
 
 #### napi_create_external_arraybuffer
 <!-- YAML
@@ -1364,7 +1368,8 @@ Returns `napi_ok` if the API succeeded.
 
 This API is used to retrieve the underlying data buffer of an ArrayBuffer and
 its length.
-WARNING: Use caution while using this API. The lifetime of the underlying data
+
+*WARNING*: Use caution while using this API. The lifetime of the underlying data
 buffer is managed by the ArrayBuffer even after it's returned. A
 possible safe way to use this API is in conjunction with [`napi_create_reference`][],
 which can be used to guarantee control over the lifetime of the
@@ -1391,7 +1396,8 @@ Returns `napi_ok` if the API succeeded.
 
 This API is used to retrieve the underlying data buffer of a `node::Buffer`
 and it's length.
-Warning: Use caution while using this API since the underlying data buffer's
+
+*Warning*: Use caution while using this API since the underlying data buffer's
 lifetime is not guaranteed if it's managed by the VM.
 
 #### *napi_get_prototype*
@@ -1438,7 +1444,8 @@ to start projecting the TypedArray.
 Returns `napi_ok` if the API succeeded.
 
 This API returns various properties of a typed array.
-Warning: Use caution while using this API since the underlying data buffer
+
+*Warning*: Use caution while using this API since the underlying data buffer
 is managed by the VM
 
 #### *napi_get_value_bool*
@@ -1457,8 +1464,8 @@ Boolean.
 Returns `napi_ok` if the API succeeded. If a non-boolean `napi_value` is
 passed in it returns `napi_boolean_expected`.
 
-This API returns C boolean primitive equivalent of the given JavaScript
-Boolea
+This API returns the C boolean primitive equivalent of the given JavaScript
+Boolean.
 
 #### *napi_get_value_double*
 <!-- YAML
@@ -1493,14 +1500,14 @@ napi_status napi_get_value_external(napi_env env,
 ```
 
 - `[in] env`: The environment that the API is invoked under.
-- `[in] value`: `napi_value` representing JavaScript External value.
-- `[out] result`: Pointer to the data wrapped by the JavaScript External value.
+- `[in] value`: `napi_value` representing JavaScript external value.
+- `[out] result`: Pointer to the data wrapped by the JavaScript external value.
 
 Returns `napi_ok` if the API succeeded. If a non-external `napi_value` is
 passed in it returns `napi_invalid_arg`.
 
-This API returns the pointer to the data wrapped by the JavaScript
-External value
+This API retrieves the external data pointer that was previously passed to
+`napi_create_external()`.
 
 #### *napi_get_value_int32*
 <!-- YAML
@@ -2770,6 +2777,7 @@ napi_status napi_wrap(napi_env env,
 Returns `napi_ok` if the API succeeded.
 
 Wraps a native instance in JavaScript object of the corresponding type.
+The native instance can be retrieved later using `napi_unwrap()`.
 
 When JavaScript code invokes a constructor for a class that was defined using
 `napi_define_class()`, the `napi_callback` for the constructor is invoked.
@@ -2787,12 +2795,16 @@ The optional returned reference is initially a weak reference, meaning it
 has a reference count of 0. Typically this reference count would be incremented
 temporarily during async operations that require the instance to remain valid.
 
-Caution: The optional returned reference (if obtained) should be deleted via
-[`napi_delete_reference`][] ONLY in response to the finalize callback invocation.
-(If it is deleted before then, then the finalize callback may never be
-invoked.) Therefore when obtaining a reference a finalize callback is also
+*Caution*: The optional returned reference (if obtained) should be deleted via
+[`napi_delete_reference`][] ONLY in response to the finalize callback
+invocation. (If it is deleted before then, then the finalize callback may never
+be invoked.) Therefore, when obtaining a reference a finalize callback is also
 required in order to enable correct proper of the reference.
 
+*Note*: This API may modify the prototype chain of the wrapper object.
+Afterward, additional manipulation of the wrapper's prototype chain may cause
+`napi_unwrap()` to fail.
+
 ### *napi_unwrap*
 <!-- YAML
 added: v8.0.0
@@ -2809,6 +2821,9 @@ napi_status napi_unwrap(napi_env env,
 
 Returns `napi_ok` if the API succeeded.
 
+Retrieves a native instance that was previously wrapped in a JavaScript
+object using `napi_wrap()`.
+
 When JavaScript code invokes a method or property accessor on the class, the
 corresponding `napi_callback` is invoked. If the callback is for an instance
 method or accessor, then the `this` argument to the callback is the wrapper
diff --git a/src/node_api.cc b/src/node_api.cc
index 7a485283bbb13d..49dd778b1371b3 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -821,9 +821,6 @@ napi_status napi_define_class(napi_env env,
   v8::Local<v8::FunctionTemplate> tpl = v8::FunctionTemplate::New(
       isolate, v8impl::FunctionCallbackWrapper::Invoke, cbdata);
 
-  // we need an internal field to stash the wrapped object
-  tpl->InstanceTemplate()->SetInternalFieldCount(1);
-
   v8::Local<v8::String> name_string;
   CHECK_NEW_FROM_UTF8(env, name_string, utf8name);
   tpl->SetClassName(name_string);
@@ -1952,14 +1949,24 @@ napi_status napi_wrap(napi_env env,
   CHECK_ARG(env, js_object);
 
   v8::Isolate* isolate = env->isolate;
-  v8::Local<v8::Object> obj =
-      v8impl::V8LocalValueFromJsValue(js_object).As<v8::Object>();
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
 
-  // Only objects that were created from a NAPI constructor's prototype
-  // via napi_define_class() can be (un)wrapped.
-  RETURN_STATUS_IF_FALSE(env, obj->InternalFieldCount() > 0, napi_invalid_arg);
+  v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(js_object);
+  RETURN_STATUS_IF_FALSE(env, value->IsObject(), napi_invalid_arg);
+  v8::Local<v8::Object> obj = value.As<v8::Object>();
+
+  // Create a wrapper object with an internal field to hold the wrapped pointer.
+  v8::Local<v8::ObjectTemplate> wrapperTemplate =
+    v8::ObjectTemplate::New(isolate);
+  wrapperTemplate->SetInternalFieldCount(1);
+  v8::Local<v8::Object> wrapper =
+    wrapperTemplate->NewInstance(context).ToLocalChecked();
+  wrapper->SetInternalField(0, v8::External::New(isolate, native_object));
 
-  obj->SetInternalField(0, v8::External::New(isolate, native_object));
+  // Insert the wrapper into the object's prototype chain.
+  v8::Local<v8::Value> proto = obj->GetPrototype();
+  wrapper->SetPrototype(proto);
+  obj->SetPrototype(wrapper);
 
   if (result != nullptr) {
     // The returned reference should be deleted via napi_delete_reference()
@@ -1990,11 +1997,18 @@ napi_status napi_unwrap(napi_env env, napi_value js_object, void** result) {
   RETURN_STATUS_IF_FALSE(env, value->IsObject(), napi_invalid_arg);
   v8::Local<v8::Object> obj = value.As<v8::Object>();
 
-  // Only objects that were created from a NAPI constructor's prototype
-  // via napi_define_class() can be (un)wrapped.
-  RETURN_STATUS_IF_FALSE(env, obj->InternalFieldCount() > 0, napi_invalid_arg);
-
-  v8::Local<v8::Value> unwrappedValue = obj->GetInternalField(0);
+  // Search the object's prototype chain for the wrapper with an internal field.
+  // Usually the wrapper would be the first in the chain, but it is OK for
+  // other objects to be inserted in the prototype chain.
+  v8::Local<v8::Object> wrapper = obj;
+  do {
+    v8::Local<v8::Value> proto = wrapper->GetPrototype();
+    RETURN_STATUS_IF_FALSE(
+      env, !proto.IsEmpty() && proto->IsObject(), napi_invalid_arg);
+    wrapper = proto.As<v8::Object>();
+  } while (wrapper->InternalFieldCount() != 1);
+
+  v8::Local<v8::Value> unwrappedValue = wrapper->GetInternalField(0);
   RETURN_STATUS_IF_FALSE(env, unwrappedValue->IsExternal(), napi_invalid_arg);
 
   *result = unwrappedValue.As<v8::External>()->Value();
diff --git a/test/addons-napi/test_object/test.js b/test/addons-napi/test_object/test.js
index d14a15421feef6..4b64fa4b381af5 100644
--- a/test/addons-napi/test_object/test.js
+++ b/test/addons-napi/test_object/test.js
@@ -31,35 +31,73 @@ assert(test_object.Has(newObject, 'test_number'));
 assert.strictEqual(newObject.test_number, 987654321);
 assert.strictEqual(newObject.test_string, 'test string');
 
-// test_object.Inflate increases all properties by 1
-const cube = {
-  x: 10,
-  y: 10,
-  z: 10
-};
+{
+  // test_object.Inflate increases all properties by 1
+  const cube = {
+    x: 10,
+    y: 10,
+    z: 10
+  };
 
-assert.deepStrictEqual(test_object.Inflate(cube), {x: 11, y: 11, z: 11});
-assert.deepStrictEqual(test_object.Inflate(cube), {x: 12, y: 12, z: 12});
-assert.deepStrictEqual(test_object.Inflate(cube), {x: 13, y: 13, z: 13});
-cube.t = 13;
-assert.deepStrictEqual(test_object.Inflate(cube), {x: 14, y: 14, z: 14, t: 14});
-
-const sym1 = Symbol('1');
-const sym2 = Symbol('2');
-const sym3 = Symbol('3');
-const sym4 = Symbol('4');
-const object2 = {
-  [sym1]: '@@iterator',
-  [sym2]: sym3
-};
+  assert.deepStrictEqual(test_object.Inflate(cube), {x: 11, y: 11, z: 11});
+  assert.deepStrictEqual(test_object.Inflate(cube), {x: 12, y: 12, z: 12});
+  assert.deepStrictEqual(test_object.Inflate(cube), {x: 13, y: 13, z: 13});
+  cube.t = 13;
+  assert.deepStrictEqual(
+    test_object.Inflate(cube), {x: 14, y: 14, z: 14, t: 14});
+
+  const sym1 = Symbol('1');
+  const sym2 = Symbol('2');
+  const sym3 = Symbol('3');
+  const sym4 = Symbol('4');
+  const object2 = {
+    [sym1]: '@@iterator',
+    [sym2]: sym3
+  };
+
+  assert(test_object.Has(object2, sym1));
+  assert(test_object.Has(object2, sym2));
+  assert.strictEqual(test_object.Get(object2, sym1), '@@iterator');
+  assert.strictEqual(test_object.Get(object2, sym2), sym3);
+  assert(test_object.Set(object2, 'string', 'value'));
+  assert(test_object.Set(object2, sym4, 123));
+  assert(test_object.Has(object2, 'string'));
+  assert(test_object.Has(object2, sym4));
+  assert.strictEqual(test_object.Get(object2, 'string'), 'value');
+  assert.strictEqual(test_object.Get(object2, sym4), 123);
+}
+
+{
+  // Wrap a pointer in a JS object, then verify the pointer can be unwrapped.
+  const wrapper = {};
+  test_object.Wrap(wrapper);
+
+  assert(test_object.Unwrap(wrapper));
+}
+
+{
+  // Verify that wrapping doesn't break an object's prototype chain.
+  const wrapper = {};
+  const protoA = { protoA: true };
+  Object.setPrototypeOf(wrapper, protoA);
+  test_object.Wrap(wrapper);
+
+  assert(test_object.Unwrap(wrapper));
+  assert(wrapper.protoA);
+}
+
+{
+  // Verify the pointer can be unwrapped after inserting in the prototype chain.
+  const wrapper = {};
+  const protoA = { protoA: true };
+  Object.setPrototypeOf(wrapper, protoA);
+  test_object.Wrap(wrapper);
+
+  const protoB = { protoB: true };
+  Object.setPrototypeOf(protoB, Object.getPrototypeOf(wrapper));
+  Object.setPrototypeOf(wrapper, protoB);
 
-assert(test_object.Has(object2, sym1));
-assert(test_object.Has(object2, sym2));
-assert.strictEqual(test_object.Get(object2, sym1), '@@iterator');
-assert.strictEqual(test_object.Get(object2, sym2), sym3);
-assert(test_object.Set(object2, 'string', 'value'));
-assert(test_object.Set(object2, sym4, 123));
-assert(test_object.Has(object2, 'string'));
-assert(test_object.Has(object2, sym4));
-assert.strictEqual(test_object.Get(object2, 'string'), 'value');
-assert.strictEqual(test_object.Get(object2, sym4), 123);
+  assert(test_object.Unwrap(wrapper));
+  assert(wrapper.protoA, true);
+  assert(wrapper.protoB, true);
+}
diff --git a/test/addons-napi/test_object/test_object.c b/test/addons-napi/test_object/test_object.c
index 9e02c1d0bb7197..dd2db123f740c2 100644
--- a/test/addons-napi/test_object/test_object.c
+++ b/test/addons-napi/test_object/test_object.c
@@ -1,6 +1,7 @@
 #include <node_api.h>
 #include "../common.h"
 #include <string.h>
+#include <stdlib.h>
 
 napi_value Get(napi_env env, napi_callback_info info) {
   size_t argc = 2;
@@ -138,6 +139,30 @@ napi_value Inflate(napi_env env, napi_callback_info info) {
   return obj;
 }
 
+napi_value Wrap(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value arg;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &arg, NULL, NULL));
+
+  int32_t* data = malloc(sizeof(int32_t));
+  *data = 3;
+  NAPI_CALL(env, napi_wrap(env, arg, data, NULL, NULL, NULL));
+  return NULL;
+}
+
+napi_value Unwrap(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value arg;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &arg, NULL, NULL));
+
+  int32_t* data;
+  NAPI_CALL(env, napi_unwrap(env, arg, &data));
+
+  napi_value result;
+  NAPI_CALL(env, napi_get_boolean(env, data != NULL && *data == 3, &result));
+  return result;
+}
+
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("Get", Get),
@@ -145,6 +170,8 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("Has", Has),
     DECLARE_NAPI_PROPERTY("New", New),
     DECLARE_NAPI_PROPERTY("Inflate", Inflate),
+    DECLARE_NAPI_PROPERTY("Wrap", Wrap),
+    DECLARE_NAPI_PROPERTY("Unwrap", Unwrap),
   };
 
   NAPI_CALL_RETURN_VOID(env, napi_define_properties(

From 2052c6ad60c5ce8bac285f270b59b3f24803c0b3 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Tue, 30 May 2017 17:47:05 -0400
Subject: [PATCH 054/183] test: consolidate n-api test addons

It takes time to build each of the addons used to test n-api.
Consolidate a few of the smaller ones to save build time.

PR-URL: https://github.com/nodejs/node/pull/13317
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Gibson Fahnestock <gibfahn@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 .../test.js => test_general/testGlobals.js}   |  2 +-
 .../testInstanceOf.js}                        |  2 +-
 test/addons-napi/test_general/test_general.c  | 29 +++++++++++++++++++
 test/addons-napi/test_globals/binding.gyp     |  8 -----
 test/addons-napi/test_globals/test_globals.c  | 26 -----------------
 test/addons-napi/test_instanceof/binding.gyp  |  8 -----
 .../test_instanceof/test_instanceof.c         | 28 ------------------
 7 files changed, 31 insertions(+), 72 deletions(-)
 rename test/addons-napi/{test_globals/test.js => test_general/testGlobals.js} (96%)
 rename test/addons-napi/{test_instanceof/test.js => test_general/testInstanceOf.js} (97%)
 delete mode 100644 test/addons-napi/test_globals/binding.gyp
 delete mode 100644 test/addons-napi/test_globals/test_globals.c
 delete mode 100644 test/addons-napi/test_instanceof/binding.gyp
 delete mode 100644 test/addons-napi/test_instanceof/test_instanceof.c

diff --git a/test/addons-napi/test_globals/test.js b/test/addons-napi/test_general/testGlobals.js
similarity index 96%
rename from test/addons-napi/test_globals/test.js
rename to test/addons-napi/test_general/testGlobals.js
index a6e5f722cb9379..38cf3f3edbccbc 100644
--- a/test/addons-napi/test_globals/test.js
+++ b/test/addons-napi/test_general/testGlobals.js
@@ -2,7 +2,7 @@
 const common = require('../../common');
 const assert = require('assert');
 
-const test_globals = require(`./build/${common.buildType}/test_globals`);
+const test_globals = require(`./build/${common.buildType}/test_general`);
 
 assert.strictEqual(test_globals.getUndefined(), undefined);
 assert.strictEqual(test_globals.getNull(), null);
diff --git a/test/addons-napi/test_instanceof/test.js b/test/addons-napi/test_general/testInstanceOf.js
similarity index 97%
rename from test/addons-napi/test_instanceof/test.js
rename to test/addons-napi/test_general/testInstanceOf.js
index 418149d1909e6f..3279979719dc37 100644
--- a/test/addons-napi/test_instanceof/test.js
+++ b/test/addons-napi/test_general/testInstanceOf.js
@@ -6,7 +6,7 @@ const assert = require('assert');
 
 // addon is referenced through the eval expression in testFile
 // eslint-disable-next-line no-unused-vars
-const addon = require(`./build/${common.buildType}/test_instanceof`);
+const addon = require(`./build/${common.buildType}/test_general`);
 const path = require('path');
 
 // The following assert functions are referenced by v8's unit tests
diff --git a/test/addons-napi/test_general/test_general.c b/test/addons-napi/test_general/test_general.c
index 585a3bf2b3ff0d..5d974081a4d8c9 100644
--- a/test/addons-napi/test_general/test_general.c
+++ b/test/addons-napi/test_general/test_general.c
@@ -33,11 +33,40 @@ napi_value testGetVersion(napi_env env, napi_callback_info info) {
   return result;
 }
 
+napi_value doInstanceOf(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value args[2];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  bool instanceof;
+  NAPI_CALL(env, napi_instanceof(env, args[0], args[1], &instanceof));
+
+  napi_value result;
+  NAPI_CALL(env, napi_get_boolean(env, instanceof, &result));
+
+  return result;
+}
+
+napi_value getNull(napi_env env, napi_callback_info info) {
+  napi_value result;
+  NAPI_CALL(env, napi_get_null(env, &result));
+  return result;
+}
+
+napi_value getUndefined(napi_env env, napi_callback_info info) {
+  napi_value result;
+  NAPI_CALL(env, napi_get_undefined(env, &result));
+  return result;
+}
+
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("testStrictEquals", testStrictEquals),
     DECLARE_NAPI_PROPERTY("testGetPrototype", testGetPrototype),
     DECLARE_NAPI_PROPERTY("testGetVersion", testGetVersion),
+    DECLARE_NAPI_PROPERTY("doInstanceOf", doInstanceOf),
+    DECLARE_NAPI_PROPERTY("getUndefined", getUndefined),
+    DECLARE_NAPI_PROPERTY("getNull", getNull),
   };
 
   NAPI_CALL_RETURN_VOID(env, napi_define_properties(
diff --git a/test/addons-napi/test_globals/binding.gyp b/test/addons-napi/test_globals/binding.gyp
deleted file mode 100644
index 0160dc72e18017..00000000000000
--- a/test/addons-napi/test_globals/binding.gyp
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "targets": [
-    {
-      "target_name": "test_globals",
-      "sources": [ "test_globals.c" ]
-    }
-  ]
-}
diff --git a/test/addons-napi/test_globals/test_globals.c b/test/addons-napi/test_globals/test_globals.c
deleted file mode 100644
index 709e42a2e0e6c8..00000000000000
--- a/test/addons-napi/test_globals/test_globals.c
+++ /dev/null
@@ -1,26 +0,0 @@
-#include <node_api.h>
-#include "../common.h"
-
-napi_value getNull(napi_env env, napi_callback_info info) {
-  napi_value result;
-  NAPI_CALL(env, napi_get_null(env, &result));
-  return result;
-}
-
-napi_value getUndefined(napi_env env, napi_callback_info info) {
-  napi_value result;
-  NAPI_CALL(env, napi_get_undefined(env, &result));
-  return result;
-}
-
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_property_descriptor descriptors[] = {
-    DECLARE_NAPI_PROPERTY("getUndefined", getUndefined),
-    DECLARE_NAPI_PROPERTY("getNull", getNull),
-  };
-
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
-}
-
-NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_instanceof/binding.gyp b/test/addons-napi/test_instanceof/binding.gyp
deleted file mode 100644
index 7fca7e0736d410..00000000000000
--- a/test/addons-napi/test_instanceof/binding.gyp
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "targets": [
-    {
-      "target_name": "test_instanceof",
-      "sources": [ "test_instanceof.c" ]
-    }
-  ]
-}
diff --git a/test/addons-napi/test_instanceof/test_instanceof.c b/test/addons-napi/test_instanceof/test_instanceof.c
deleted file mode 100644
index 76a6542830959d..00000000000000
--- a/test/addons-napi/test_instanceof/test_instanceof.c
+++ /dev/null
@@ -1,28 +0,0 @@
-#include <node_api.h>
-#include <stdio.h>
-#include "../common.h"
-
-napi_value doInstanceOf(napi_env env, napi_callback_info info) {
-  size_t argc = 2;
-  napi_value args[2];
-  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
-
-  bool instanceof;
-  NAPI_CALL(env, napi_instanceof(env, args[0], args[1], &instanceof));
-
-  napi_value result;
-  NAPI_CALL(env, napi_get_boolean(env, instanceof, &result));
-
-  return result;
-}
-
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_property_descriptor descriptors[] = {
-    DECLARE_NAPI_PROPERTY("doInstanceOf", doInstanceOf),
-  };
-
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
-}
-
-NAPI_MODULE(addon, Init)

From d572b0f0dc7a77cd5ea69e89f6168d608d869291 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Thu, 1 Jun 2017 18:35:26 -0400
Subject: [PATCH 055/183] test: consolidate n-api test addons - part2

It takes time to build each of the addons used to test n-api.
Consolidate a few of the smaller ones to save build time.

Get rid of one more small addon.

PR-URL: https://github.com/nodejs/node/pull/13380
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 .../testNapiStatus.js}                        |  2 +-
 test/addons-napi/test_general/test_general.c  | 33 ++++++++++++++
 test/addons-napi/test_napi_status/binding.gyp |  8 ----
 .../test_napi_status/test_napi_status.cc      | 45 -------------------
 4 files changed, 34 insertions(+), 54 deletions(-)
 rename test/addons-napi/{test_napi_status/test.js => test_general/testNapiStatus.js} (73%)
 delete mode 100644 test/addons-napi/test_napi_status/binding.gyp
 delete mode 100644 test/addons-napi/test_napi_status/test_napi_status.cc

diff --git a/test/addons-napi/test_napi_status/test.js b/test/addons-napi/test_general/testNapiStatus.js
similarity index 73%
rename from test/addons-napi/test_napi_status/test.js
rename to test/addons-napi/test_general/testNapiStatus.js
index 60c4f693b2d951..a588862098f68f 100644
--- a/test/addons-napi/test_napi_status/test.js
+++ b/test/addons-napi/test_general/testNapiStatus.js
@@ -1,7 +1,7 @@
 'use strict';
 
 const common = require('../../common');
-const addon = require(`./build/${common.buildType}/test_napi_status`);
+const addon = require(`./build/${common.buildType}/test_general`);
 const assert = require('assert');
 
 addon.createNapiError();
diff --git a/test/addons-napi/test_general/test_general.c b/test/addons-napi/test_general/test_general.c
index 5d974081a4d8c9..0b69cc41e29fb5 100644
--- a/test/addons-napi/test_general/test_general.c
+++ b/test/addons-napi/test_general/test_general.c
@@ -59,6 +59,37 @@ napi_value getUndefined(napi_env env, napi_callback_info info) {
   return result;
 }
 
+napi_value createNapiError(napi_env env, napi_callback_info info) {
+  napi_value value;
+  NAPI_CALL(env, napi_create_string_utf8(env, "xyz", 3, &value));
+
+  double double_value;
+  napi_status status = napi_get_value_double(env, value, &double_value);
+
+  NAPI_ASSERT(env, status != napi_ok, "Failed to produce error condition");
+
+  const napi_extended_error_info *error_info = 0;
+  NAPI_CALL(env, napi_get_last_error_info(env, &error_info));
+
+  NAPI_ASSERT(env, error_info->error_code == status,
+    "Last error info code should match last status");
+  NAPI_ASSERT(env, error_info->error_message,
+    "Last error info message should not be null");
+
+  return NULL;
+}
+
+napi_value testNapiErrorCleanup(napi_env env, napi_callback_info info) {
+  const napi_extended_error_info *error_info = 0;
+  NAPI_CALL(env, napi_get_last_error_info(env, &error_info));
+
+  napi_value result;
+  bool is_ok = error_info->error_code == napi_ok;
+  NAPI_CALL(env, napi_get_boolean(env, is_ok, &result));
+
+  return result;
+}
+
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("testStrictEquals", testStrictEquals),
@@ -67,6 +98,8 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("doInstanceOf", doInstanceOf),
     DECLARE_NAPI_PROPERTY("getUndefined", getUndefined),
     DECLARE_NAPI_PROPERTY("getNull", getNull),
+    DECLARE_NAPI_PROPERTY("createNapiError", createNapiError),
+    DECLARE_NAPI_PROPERTY("testNapiErrorCleanup", testNapiErrorCleanup),
   };
 
   NAPI_CALL_RETURN_VOID(env, napi_define_properties(
diff --git a/test/addons-napi/test_napi_status/binding.gyp b/test/addons-napi/test_napi_status/binding.gyp
deleted file mode 100644
index 01ace540a99781..00000000000000
--- a/test/addons-napi/test_napi_status/binding.gyp
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "targets": [
-    {
-      "target_name": "test_napi_status",
-      "sources": [ "test_napi_status.cc" ]
-    }
-  ]
-}
diff --git a/test/addons-napi/test_napi_status/test_napi_status.cc b/test/addons-napi/test_napi_status/test_napi_status.cc
deleted file mode 100644
index 9e340aa46e106c..00000000000000
--- a/test/addons-napi/test_napi_status/test_napi_status.cc
+++ /dev/null
@@ -1,45 +0,0 @@
-#include <node_api.h>
-#include "../common.h"
-
-napi_value createNapiError(napi_env env, napi_callback_info info) {
-  napi_value value;
-  NAPI_CALL(env, napi_create_string_utf8(env, "xyz", 3, &value));
-
-  double double_value;
-  napi_status status = napi_get_value_double(env, value, &double_value);
-
-  NAPI_ASSERT(env, status != napi_ok, "Failed to produce error condition");
-
-  const napi_extended_error_info *error_info = 0;
-  NAPI_CALL(env, napi_get_last_error_info(env, &error_info));
-
-  NAPI_ASSERT(env, error_info->error_code == status,
-    "Last error info code should match last status");
-  NAPI_ASSERT(env, error_info->error_message,
-    "Last error info message should not be null");
-
-  return nullptr;
-}
-
-napi_value testNapiErrorCleanup(napi_env env, napi_callback_info info) {
-  const napi_extended_error_info *error_info = 0;
-  NAPI_CALL(env, napi_get_last_error_info(env, &error_info));
-
-  napi_value result;
-  bool is_ok = error_info->error_code == napi_ok;
-  NAPI_CALL(env, napi_get_boolean(env, is_ok, &result));
-
-  return result;
-}
-
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_property_descriptor descriptors[] = {
-    DECLARE_NAPI_PROPERTY("createNapiError", createNapiError),
-    DECLARE_NAPI_PROPERTY("testNapiErrorCleanup", testNapiErrorCleanup),
-  };
-
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
-}
-
-NAPI_MODULE(addon, Init)

From 28cf8f047aa7127136292e7a0a7ff0acb6cef5a2 Mon Sep 17 00:00:00 2001
From: Jason Ginchereau <jasongin@microsoft.com>
Date: Fri, 2 Jun 2017 12:32:18 -0700
Subject: [PATCH 056/183] test: fix build warning in addons-napi/test_object

PR-URL: https://github.com/nodejs/node/pull/13412
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 test/addons-napi/test_object/test_object.c | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/test/addons-napi/test_object/test_object.c b/test/addons-napi/test_object/test_object.c
index dd2db123f740c2..383fe46342a340 100644
--- a/test/addons-napi/test_object/test_object.c
+++ b/test/addons-napi/test_object/test_object.c
@@ -3,6 +3,8 @@
 #include <string.h>
 #include <stdlib.h>
 
+static int test_value = 3;
+
 napi_value Get(napi_env env, napi_callback_info info) {
   size_t argc = 2;
   napi_value args[2];
@@ -145,7 +147,7 @@ napi_value Wrap(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &arg, NULL, NULL));
 
   int32_t* data = malloc(sizeof(int32_t));
-  *data = 3;
+  *data = test_value;
   NAPI_CALL(env, napi_wrap(env, arg, data, NULL, NULL, NULL));
   return NULL;
 }
@@ -155,11 +157,12 @@ napi_value Unwrap(napi_env env, napi_callback_info info) {
   napi_value arg;
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &arg, NULL, NULL));
 
-  int32_t* data;
+  void* data;
   NAPI_CALL(env, napi_unwrap(env, arg, &data));
 
+  bool is_expected = (data != NULL && *(int*)data == 3);
   napi_value result;
-  NAPI_CALL(env, napi_get_boolean(env, data != NULL && *data == 3, &result));
+  NAPI_CALL(env, napi_get_boolean(env, is_expected, &result));
   return result;
 }
 

From 45be27f8c166cdeaf0731586e5e831af7c8dbe5c Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Fri, 2 Jun 2017 12:01:32 -0400
Subject: [PATCH 057/183] doc: add ref to option to enable n-api
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Since its guarded in by a command line option say
that in the docs and provide the option that needs
to be used to enable it.

PR-URL: https://github.com/nodejs/node/pull/13406
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Tobias Nießn <tniessen@tnie.de>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
Reviewed-By: Gibson Fahnestock <gibfahn@gmail.com>
---
 doc/api/n-api.md | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index ab90cf05f4750d..3f5f9f4d9d2e03 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -60,6 +60,14 @@ For example:
 #include <node_api.h>
 ```
 
+As the feature is experimental it must be enabled with the
+following command line
+[option](https://nodejs.org/dist/latest-v8.x/docs/api/cli.html#cli_napi_modules):
+
+```bash
+--napi-modules
+```
+
 ## Basic N-API Data Types
 
 N-API exposes the following fundamental datatypes as abstractions that are

From 8a9655122cf65684a31c7883c73a99c1541abeec Mon Sep 17 00:00:00 2001
From: Jamen Marz <jamenmarz+gh@gmail.com>
Date: Mon, 5 Jun 2017 16:30:00 -0500
Subject: [PATCH 058/183] doc: fix typo "ndapi" in n-api.md

PR-URL: https://github.com/nodejs/node/pull/13484
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 doc/api/n-api.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 3f5f9f4d9d2e03..52b45187736e88 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -703,7 +703,7 @@ added: v8.0.0
 NODE_EXTERN napi_status napi_create_reference(napi_env env,
                                               napi_value value,
                                               int initial_refcount,
-                                              ndapi_ref* result);
+                                              napi_ref* result);
 ```
 
 - `[in] env`: The environment that the API is invoked under.
@@ -2999,7 +2999,7 @@ support it:
 * If the function is not available, provide an alternate implementation
   that does not use the function.
 
-[Aynchronous Operations]: #n_api_asynchronous_operations
+[Asynchronous Operations]: #n_api_asynchronous_operations
 [Basic N-API Data Types]: #n_api_basic_n_api_data_types
 [ECMAScript Language Specification]: https://tc39.github.io/ecma262/
 [Error Handling]: #n_api_error_handling

From 01302b1aba9e3617eb99b7b57e9abcf7877d7ce7 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Tue, 6 Jun 2017 15:27:16 -0400
Subject: [PATCH 059/183] doc: fix out of date sections in n-api doc

PR-URL: https://github.com/nodejs/node/pull/13508
Fixes: https://github.com/nodejs/node/issues/13469
Fixes: https://github.com/nodejs/node/issues/13458
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
---
 doc/api/n-api.md | 63 ++++++++++++++++++++----------------------------
 1 file changed, 26 insertions(+), 37 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 52b45187736e88..5a343ef377cfe3 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -1560,25 +1560,6 @@ is passed in it returns `napi_number_expected`.
 This API returns the C int64 primitive equivalent of the given
 JavaScript Number
 
-#### *napi_get_value_string_length*
-<!-- YAML
-added: v8.0.0
--->
-```C
-napi_status napi_get_value_string_length(napi_env env,
-                                         napi_value value,
-                                         int* result)
-```
-
-- `[in] env`: The environment that the API is invoked under.
-- `[in] value`: `napi_value` representing JavaScript string.
-- `[out] result`: Number of characters in the given JavaScript string.
-
-Returns `napi_ok` if the API succeeded. If a non-String `napi_value`
-is passed in it returns `napi_string_expected`.
-
-This API returns the number of characters in the given JavaScript string.
-
 #### *napi_get_value_string_utf8*
 <!-- YAML
 added: v8.0.0
@@ -2100,31 +2081,32 @@ if (status != napi_ok) return status;
 ```C
 typedef enum {
   napi_default = 0,
-  napi_read_only = 1 << 0,
-  napi_dont_enum = 1 << 1,
-  napi_dont_delete = 1 << 2,
-  napi_static_property = 1 << 10,
+  napi_writable = 1 << 0,
+  napi_enumerable = 1 << 1,
+  napi_configurable = 1 << 2,
+
+  // Used with napi_define_class to distinguish static properties
+  // from instance properties. Ignored by napi_define_properties.
+  napi_static = 1 << 10,
 } napi_property_attributes;
 ```
 
 `napi_property_attributes` are flags used to control the behavior of properties
-set on a JavaScript object. They roughly correspond to the attributes listed in
-[Section 6.1.7.1](https://tc39.github.io/ecma262/#table-2) of the
-[ECMAScript Language Specification](https://tc39.github.io/ecma262/). They can
-be one or more of the following bitflags:
+set on a JavaScript object. Other than `napi_static` they correspond to the
+attributes listed in [Section 6.1.7.1](https://tc39.github.io/ecma262/#table-2)
+of the [ECMAScript Language Specification](https://tc39.github.io/ecma262/).
+They can be one or more of the following bitflags:
 
 - `napi_default` - Used to indicate that no explicit attributes are set on the
-given property. By default, a property is Writable, Enumerable, and
- Configurable. This is a deviation from the ECMAScript specification,
- where generally the values for a property descriptor attribute default to
- false if they're not provided.
-- `napi_read_only` - Used to indicate that a given property is not Writable.
-- `napi_dont_enum` - Used to indicate that a given property is not Enumerable.
-- `napi_dont_delete` - Used to indicate that a given property is not.
-Configurable, as defined in
+given property. By default, a property is read only, not enumerable and not
+configurable.
+- `napi_writable`  - Used to indicate that a given property is writable.
+- `napi_enumerable` - Used to indicate that a given property is enumerable.
+- `napi_configurable` - Used to indicate that a given property is
+configurable, as defined in
 [Section 6.1.7.1](https://tc39.github.io/ecma262/#table-2) of the
 [ECMAScript Language Specification](https://tc39.github.io/ecma262/).
-- `napi_static_property` - Used to indicate that the property will be defined as
+- `napi_static` - Used to indicate that the property will be defined as
 a static property on a class as opposed to an instance property, which is the
 default. This is used only by [`napi_define_class`][]. It is ignored by
 `napi_define_properties`.
@@ -2132,7 +2114,9 @@ default. This is used only by [`napi_define_class`][]. It is ignored by
 #### *napi_property_descriptor*
 ```C
 typedef struct {
+  // One of utf8name or name should be NULL.
   const char* utf8name;
+  napi_value name;
 
   napi_callback method;
   napi_callback getter;
@@ -2144,7 +2128,12 @@ typedef struct {
 } napi_property_descriptor;
 ```
 
-- `utf8name`: String describing the key for the property, encoded as UTF8.
+- `utf8name`: Optional String describing the key for the property,
+encoded as UTF8. One of `utf8name` or `name` must be provided for the
+property.
+- `name`: Optional napi_value that points to a JavaScript string or symbol
+to be used as the key for the property.  One of `utf8name` or `name` must
+be provided for the property.
 - `value`: The value that's retrieved by a get access of the property if the
  property is a data property. If this is passed in, set `getter`, `setter`,
  `method` and `data` to `NULL` (since these members won't be used).

From 02e7b633f46b65fac6efcbe8fe7fd5b7d0577d0d Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Tue, 6 Jun 2017 18:24:33 -0400
Subject: [PATCH 060/183] test: add coverage for napi_property_descriptor

We did not have test coverage for using a napi_value
pointing to a string or symbol for the name when
creating a property.  Add that coverage.

PR-URL: https://github.com/nodejs/node/pull/13510
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
---
 test/addons-napi/test_properties/test.js       |  8 ++++++++
 .../test_properties/test_properties.c          | 18 ++++++++++++++++++
 2 files changed, 26 insertions(+)

diff --git a/test/addons-napi/test_properties/test.js b/test/addons-napi/test_properties/test.js
index 0f37af81b7ffad..8d11a669d46daf 100644
--- a/test/addons-napi/test_properties/test.js
+++ b/test/addons-napi/test_properties/test.js
@@ -25,11 +25,19 @@ assert.ok(propertyNames.includes('echo'));
 assert.ok(propertyNames.includes('readwriteValue'));
 assert.ok(propertyNames.includes('readonlyValue'));
 assert.ok(!propertyNames.includes('hiddenValue'));
+assert.ok(propertyNames.includes('NameKeyValue'));
 assert.ok(!propertyNames.includes('readwriteAccessor1'));
 assert.ok(!propertyNames.includes('readwriteAccessor2'));
 assert.ok(!propertyNames.includes('readonlyAccessor1'));
 assert.ok(!propertyNames.includes('readonlyAccessor2'));
 
+// validate property created with symbol
+const start = 'Symbol('.length;
+const end = start + 'NameKeySymbol'.length;
+const symbolDescription =
+    String(Object.getOwnPropertySymbols(test_object)[0]).slice(start, end);
+assert.strictEqual(symbolDescription, 'NameKeySymbol');
+
 // The napi_writable attribute should be ignored for accessors.
 test_object.readwriteAccessor1 = 1;
 assert.strictEqual(test_object.readwriteAccessor1, 1);
diff --git a/test/addons-napi/test_properties/test_properties.c b/test/addons-napi/test_properties/test_properties.c
index 575d750a7d936b..3053fda4864e8f 100644
--- a/test/addons-napi/test_properties/test_properties.c
+++ b/test/addons-napi/test_properties/test_properties.c
@@ -63,11 +63,29 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_value number;
   NAPI_CALL_RETURN_VOID(env, napi_create_number(env, value_, &number));
 
+  napi_value name_value;
+  NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env,
+                                                     "NameKeyValue",
+                                                     -1,
+                                                     &name_value));
+
+  napi_value symbol_description;
+  napi_value name_symbol;
+  NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env,
+                                                     "NameKeySymbol",
+                                                      -1,
+                                                     &symbol_description));
+  NAPI_CALL_RETURN_VOID(env, napi_create_symbol(env,
+                                                symbol_description,
+                                                &name_symbol));
+
   napi_property_descriptor properties[] = {
     { "echo", 0, Echo, 0, 0, 0, napi_enumerable, 0 },
     { "readwriteValue", 0, 0, 0, 0, number, napi_enumerable | napi_writable, 0 },
     { "readonlyValue", 0, 0, 0, 0, number, napi_enumerable, 0},
     { "hiddenValue", 0, 0, 0, 0, number, napi_default, 0},
+    { NULL, name_value, 0, 0, 0, number, napi_enumerable, 0},
+    { NULL, name_symbol, 0, 0, 0, number, napi_enumerable, 0},
     { "readwriteAccessor1", 0, 0, GetValue, SetValue, 0, napi_default, 0},
     { "readwriteAccessor2", 0, 0, GetValue, SetValue, 0, napi_writable, 0},
     { "readonlyAccessor1", 0, 0, GetValue, NULL, 0, napi_default, 0},

From 2ff76928ebea17095046d6df10a846ef96ef80a7 Mon Sep 17 00:00:00 2001
From: Jamen Marzonie <jamenmarz@gmail.com>
Date: Thu, 8 Jun 2017 05:05:19 -0500
Subject: [PATCH 061/183] doc: fix napi_create_*_error signatures in n-api

PR-URL: https://github.com/nodejs/node/pull/13544
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna M. Kedzierska <anna.m.kedzierska@gmail.com>
Reviewed-By: Chris Dickinson <christopher.s.dickinson@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
---
 doc/api/n-api.md | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 5a343ef377cfe3..72b35f3810bbbd 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -407,7 +407,9 @@ This API queries a `napi_value` to check if it represents an error object.
 added: v8.0.0
 -->
 ```C
-NODE_EXTERN napi_status napi_create_error(napi_env env, const char* msg);
+NODE_EXTERN napi_status napi_create_error(napi_env env,
+                                          const char* msg,
+                                          napi_value* result);
 ```
 - `[in] env`: The environment that the API is invoked under.
 - `[in] msg`: C string representing the text to be associated with.
@@ -422,7 +424,9 @@ This API returns a JavaScript Error with the text provided.
 added: v8.0.0
 -->
 ```C
-NODE_EXTERN napi_status napi_create_type_error(napi_env env, const char* msg);
+NODE_EXTERN napi_status napi_create_type_error(napi_env env,
+                                               const char* msg,
+                                               napi_value* result);
 ```
 - `[in] env`: The environment that the API is invoked under.
 - `[in] msg`: C string representing the text to be associated with.
@@ -438,7 +442,9 @@ This API returns a JavaScript TypeError with the text provided.
 added: v8.0.0
 -->
 ```C
-NODE_EXTERN napi_status napi_create_range_error(napi_env env, const char* msg);
+NODE_EXTERN napi_status napi_create_range_error(napi_env env,
+                                                const char* msg,
+                                                napi_value* result);
 ```
 - `[in] env`: The environment that the API is invoked under.
 - `[in] msg`: C string representing the text to be associated with.

From 2b94a31893ab321fdac81fb0f4db165007cee78c Mon Sep 17 00:00:00 2001
From: XadillaX <admin@xcoder.in>
Date: Fri, 9 Jun 2017 18:14:22 +0800
Subject: [PATCH 062/183] doc: fix out of date napi_callback doc

The earlier version `napi_callback` returns `void` but now is
`napi_value`. The document of this section hasn't been modified.

PR-URL: https://github.com/nodejs/node/pull/13570
Fixes: https://github.com/nodejs/node/issues/12248
Fixes: https://github.com/nodejs/node/issues/13562
Reviewed-By: Gibson Fahnestock <gibfahn@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 doc/api/n-api.md | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 72b35f3810bbbd..da93f7c9d67c65 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -161,18 +161,16 @@ For more details, review the [Object Lifetime Management][].
 
 ### N-API Callback types
 #### *napi_callback_info*
-Opaque datatype that is passed to a callback function. It can be used for two
-purposes:
-- Get additional information about the context in which the callback was
-  invoked.
-- Set the return value of the callback.
+Opaque datatype that is passed to a callback function. It can be used for
+getting additional information about the context in which the callback was
+invoked.
 
 #### *napi_callback*
 Function pointer type for user-provided native functions which are to be
 exposed to JavaScript via N-API. Callback functions should satisfy the
 following signature:
 ```C
-typedef void (*napi_callback)(napi_env, napi_callback_info);
+typedef napi_value (*napi_callback)(napi_env, napi_callback_info);
 ```
 
 #### *napi_finalize*
@@ -2516,8 +2514,9 @@ In order to expose a function as part of the
 add-on's module exports, set the newly created function on the exports
 object. A sample module might look as follows:
 ```C
-void SayHello(napi_env env, napi_callback_info info) {
+napi_value SayHello(napi_env env, napi_callback_info info) {
   printf("Hello\n");
+  return nullptr;
 }
 
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {

From 00ee0277ad1b4cabdf9dd4d4064e578646275613 Mon Sep 17 00:00:00 2001
From: Michael Dawson <mdawson@devrus.com>
Date: Tue, 13 Jun 2017 01:02:52 -0400
Subject: [PATCH 063/183] doc: fix a few n-api doc issues

- Add doc for napi_create_string_latin1().
- Fix signatures where c string was specified instead of napi_value.
- Fix return type of napi_callback.
- Update to specify that napi_escape_handle() can only be called once
  for a given scope.

PR-URL: https://github.com/nodejs/node/pull/13650
Fixes: https://github.com/nodejs/node/issues/13555
Fixes: https://github.com/nodejs/node/issues/13556
Fixes: https://github.com/nodejs/node/issues/13562
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
Reviewed-By: Ingvar Stepanyan <me@rreverser.com>
---
 doc/api/n-api.md | 69 ++++++++++++++++++++++++++++++++++--------------
 1 file changed, 49 insertions(+), 20 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index da93f7c9d67c65..f8154d2cb490ec 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -406,11 +406,12 @@ added: v8.0.0
 -->
 ```C
 NODE_EXTERN napi_status napi_create_error(napi_env env,
-                                          const char* msg,
+                                          napi_value msg,
                                           napi_value* result);
 ```
 - `[in] env`: The environment that the API is invoked under.
-- `[in] msg`: C string representing the text to be associated with.
+- `[in] msg`: napi_value that references a JavaScript String to be
+used as the message for the Error.
 - `[out] result`: `napi_value` representing the error created.
 
 Returns `napi_ok` if the API succeeded.
@@ -423,11 +424,12 @@ added: v8.0.0
 -->
 ```C
 NODE_EXTERN napi_status napi_create_type_error(napi_env env,
-                                               const char* msg,
+                                               napi_value msg,
                                                napi_value* result);
 ```
 - `[in] env`: The environment that the API is invoked under.
-- `[in] msg`: C string representing the text to be associated with.
+- `[in] msg`: napi_value that references a JavaScript String to be
+used as the message for the Error.
 - `[out] result`: `napi_value` representing the error created.
 
 Returns `napi_ok` if the API succeeded.
@@ -445,7 +447,8 @@ NODE_EXTERN napi_status napi_create_range_error(napi_env env,
                                                 napi_value* result);
 ```
 - `[in] env`: The environment that the API is invoked under.
-- `[in] msg`: C string representing the text to be associated with.
+- `[in] msg`: napi_value that references a JavaScript String to be
+used as the message for the Error.
 - `[out] result`: `napi_value` representing the error created.
 
 Returns `napi_ok` if the API succeeded.
@@ -562,16 +565,17 @@ for (int i = 0; i < 1000000; i++) {
 ```
 
 When nesting scopes, there are cases where a handle from an
-inner scope needs  to live beyond the lifespan of that scope. N-API supports an
+inner scope needs to live beyond the lifespan of that scope. N-API supports an
 'escapable scope' in order to support this case. An escapable scope
-allows one or more handles to be 'promoted' so that they 'escape' the
-current scope and the lifespan of the handle(s) changes from the current
+allows one handle to be 'promoted' so that it 'escapes' the
+current scope and the lifespan of the handle changes from the current
 scope to that of the outer scope.
 
 The methods available to open/close escapable scopes are
 [`napi_open_escapable_handle_scope`][] and [`napi_close_escapable_handle_scope`][].
 
-The request to promote a handle is made through the [`napi_escape_handle`][].
+The request to promote a handle is made through [`napi_escape_handle`][] which
+can only be called once.
 
 #### napi_open_handle_scope
 <!-- YAML
@@ -618,7 +622,7 @@ NODE_EXTERN napi_status
 
 Returns `napi_ok` if the API succeeded.
 
-This API open a new scope from which objects can be promoted
+This API open a new scope from which one object can be promoted
 to the outer scope.
 
 #### napi_close_escapable_handle_scope
@@ -657,9 +661,9 @@ Object in the outer scope.
 
 Returns `napi_ok` if the API succeeded.
 
-This API promotes the handle to the JavaScript object so that it valid
-for the lifetime of the outer scope.
-
+This API promotes the handle to the JavaScript object so that it is valid
+for the lifetime of the outer scope. It can only be called once per scope.
+If it is called more than once an error will be returned.
 
 ### References to objects with a lifespan longer than that of the native method
 In some cases an addon will need to be able to create and reference objects
@@ -1212,13 +1216,13 @@ added: v8.0.0
 -->
 ```C
 napi_status napi_create_symbol(napi_env env,
-                               const char* description,
+                               napi_value description,
                                napi_value* result)
 ```
 
 - `[in] env`: The environment that the API is invoked under.
-- `[in] description`: Null-terminated character buffer representing a
-UTF8-encoded string to describe the symbol.
+- `[in] description`: Optional napi_value which refers to a JavaScript
+String to be set as the description for the symbol.
 - `[out] result`: A `napi_value` representing a JavaScript Symbol.
 
 Returns `napi_ok` if the API succeeded.
@@ -1299,8 +1303,8 @@ napi_status napi_create_string_utf16(napi_env env,
 
 - `[in] env`: The environment that the API is invoked under.
 - `[in] str`: Character buffer representing a UTF16-LE-encoded string.
-- `[in] length`: The length of the string in characters, or -1 if it is
-null-terminated.
+- `[in] length`: The length of the string in two-byte code units, or -1 if
+it is null-terminated.
 - `[out] result`: A `napi_value` representing a JavaScript String.
 
 Returns `napi_ok` if the API succeeded.
@@ -1311,6 +1315,31 @@ The JavaScript String type is described in
 [Section 6.1.4](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type)
 of the ECMAScript Language Specification.
 
+#### *napi_create_string_latin1*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NAPI_EXTERN napi_status napi_create_string_latin1(napi_env env,
+                                                  const char* str,
+                                                  size_t length,
+                                                  napi_value* result);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] str`: Character buffer representing a latin1-encoded string.
+- `[in] length`: The length of the string in bytes, or -1 if it is
+null-terminated.
+- `[out] result`: A `napi_value` representing a JavaScript String.
+
+Returns `napi_ok` if the API succeeded.
+
+This API creates a JavaScript String object from a latin1-encoded C string.
+
+The JavaScript String type is described in
+[Section 6.1.4](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type)
+of the ECMAScript Language Specification.
+
 #### *napi_create_string_utf8*
 <!-- YAML
 added: v8.0.0
@@ -1323,8 +1352,8 @@ napi_status napi_create_string_utf8(napi_env env,
 ```
 
 - `[in] env`: The environment that the API is invoked under.
-- `[in] s`: Character buffer representing a UTF8-encoded string.
-- `[in] length`: The length of the string in characters, or -1 if it is
+- `[in] str`: Character buffer representing a UTF8-encoded string.
+- `[in] length`: The length of the string in bytes, or -1 if it is
 null-terminated.
 - `[out] result`: A `napi_value` representing a JavaScript String.
 

From f680c08fce745c275251074d0ed8b97e4a5887a7 Mon Sep 17 00:00:00 2001
From: Michael Dawson <mdawson@devrus.com>
Date: Tue, 13 Jun 2017 00:40:00 -0400
Subject: [PATCH 064/183] n-api: avoid crash in napi_escape_scope()

V8 will crash if escape is called twice on the same
scope.

Add checks to avoid crashing if napi_escape_scope() is
called to try and do this.

Add test that tries to call napi_create_scope() twice.

PR-URL: https://github.com/nodejs/node/pull/13651
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
---
 src/node_api.cc                               | 30 ++++++++++++++-----
 src/node_api_types.h                          |  2 +-
 test/addons-napi/test_handle_scope/test.js    |  6 ++++
 .../test_handle_scope/test_handle_scope.c     | 14 +++++++++
 4 files changed, 44 insertions(+), 8 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 49dd778b1371b3..8cfaed7354626e 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -10,6 +10,7 @@
 
 #include <node_buffer.h>
 #include <node_object_wrap.h>
+
 #include <string.h>
 #include <algorithm>
 #include <cassert>
@@ -17,6 +18,7 @@
 #include <vector>
 #include "uv.h"
 #include "node_api.h"
+#include "node_internals.h"
 #include "env-inl.h"
 #include "node_api_backport.h"
 
@@ -160,14 +162,20 @@ class HandleScopeWrapper {
 // across different versions.
 class EscapableHandleScopeWrapper {
  public:
-  explicit EscapableHandleScopeWrapper(v8::Isolate* isolate) : scope(isolate) {}
+  explicit EscapableHandleScopeWrapper(v8::Isolate* isolate)
+      : scope(isolate), escape_called_(false) {}
+  bool escape_called() const {
+    return escape_called_;
+  }
   template <typename T>
   v8::Local<T> Escape(v8::Local<T> handle) {
+    escape_called_ = true;
     return scope.Escape(handle);
   }
 
  private:
   v8::EscapableHandleScope scope;
+  bool escape_called_;
 };
 
 napi_handle_scope JsHandleScopeFromV8HandleScope(HandleScopeWrapper* s) {
@@ -720,7 +728,8 @@ const char* error_messages[] = {nullptr,
                                 "An array was expected",
                                 "Unknown failure",
                                 "An exception is pending",
-                                "The async work item was cancelled"};
+                                "The async work item was cancelled",
+                                "napi_escape_handle already called on scope"};
 
 static napi_status napi_clear_last_error(napi_env env) {
   CHECK_ENV(env);
@@ -748,10 +757,14 @@ napi_status napi_get_last_error_info(napi_env env,
   CHECK_ENV(env);
   CHECK_ARG(env, result);
 
+  // you must update this assert to reference the last message
+  // in the napi_status enum each time a new error message is added.
+  // We don't have a napi_status_last as this would result in an ABI
+  // change each time a message was added.
   static_assert(
-      (sizeof (error_messages) / sizeof (*error_messages)) == napi_status_last,
+      node::arraysize(error_messages) == napi_escape_called_twice + 1,
       "Count of error messages must match count of error values");
-  assert(env->last_error.error_code < napi_status_last);
+  assert(env->last_error.error_code <= napi_escape_called_twice);
 
   // Wait until someone requests the last error information to fetch the error
   // message string
@@ -2213,9 +2226,12 @@ napi_status napi_escape_handle(napi_env env,
 
   v8impl::EscapableHandleScopeWrapper* s =
       v8impl::V8EscapableHandleScopeFromJsEscapableHandleScope(scope);
-  *result = v8impl::JsValueFromV8LocalValue(
-      s->Escape(v8impl::V8LocalValueFromJsValue(escapee)));
-  return napi_clear_last_error(env);
+  if (!s->escape_called()) {
+    *result = v8impl::JsValueFromV8LocalValue(
+        s->Escape(v8impl::V8LocalValueFromJsValue(escapee)));
+    return napi_clear_last_error(env);
+  }
+  return napi_set_last_error(env, napi_escape_called_twice);
 }
 
 napi_status napi_new_instance(napi_env env,
diff --git a/src/node_api_types.h b/src/node_api_types.h
index 4bf1b8263139d8..43102c519c03f9 100644
--- a/src/node_api_types.h
+++ b/src/node_api_types.h
@@ -67,7 +67,7 @@ typedef enum {
   napi_generic_failure,
   napi_pending_exception,
   napi_cancelled,
-  napi_status_last
+  napi_escape_called_twice
 } napi_status;
 
 typedef napi_value (*napi_callback)(napi_env env,
diff --git a/test/addons-napi/test_handle_scope/test.js b/test/addons-napi/test_handle_scope/test.js
index 20bee78882f071..cb687d0bcbf413 100644
--- a/test/addons-napi/test_handle_scope/test.js
+++ b/test/addons-napi/test_handle_scope/test.js
@@ -10,6 +10,12 @@ testHandleScope.NewScope();
 
 assert.ok(testHandleScope.NewScopeEscape() instanceof Object);
 
+assert.throws(
+  () => {
+    testHandleScope.NewScopeEscapeTwice();
+  },
+  Error);
+
 assert.throws(
   () => {
     testHandleScope.NewScopeWithException(() => { throw new RangeError(); });
diff --git a/test/addons-napi/test_handle_scope/test_handle_scope.c b/test/addons-napi/test_handle_scope/test_handle_scope.c
index 6bcee16fda713e..6637da82316185 100644
--- a/test/addons-napi/test_handle_scope/test_handle_scope.c
+++ b/test/addons-napi/test_handle_scope/test_handle_scope.c
@@ -29,6 +29,19 @@ napi_value NewScopeEscape(napi_env env, napi_callback_info info) {
   return escapee;
 }
 
+napi_value NewScopeEscapeTwice(napi_env env, napi_callback_info info) {
+  napi_escapable_handle_scope scope;
+  napi_value output = NULL;
+  napi_value escapee = NULL;
+
+  NAPI_CALL(env, napi_open_escapable_handle_scope(env, &scope));
+  NAPI_CALL(env, napi_create_object(env, &output));
+  NAPI_CALL(env, napi_escape_handle(env, scope, output, &escapee));
+  NAPI_CALL(env, napi_escape_handle(env, scope, output, &escapee));
+  NAPI_CALL(env, napi_close_escapable_handle_scope(env, scope));
+  return escapee;
+}
+
 napi_value NewScopeWithException(napi_env env, napi_callback_info info) {
   napi_handle_scope scope;
   size_t argc;
@@ -57,6 +70,7 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor properties[] = {
     DECLARE_NAPI_PROPERTY("NewScope", NewScope),
     DECLARE_NAPI_PROPERTY("NewScopeEscape", NewScopeEscape),
+    DECLARE_NAPI_PROPERTY("NewScopeEscapeTwice", NewScopeEscapeTwice),
     DECLARE_NAPI_PROPERTY("NewScopeWithException", NewScopeWithException),
   };
 

From 512fc32bc190ae79891cad8823de0486bb999a08 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Mon, 26 Jun 2017 18:41:25 -0400
Subject: [PATCH 065/183] doc: doc lifetime of n-api last error info

Document the lifetime of the structure returned
by napi_get_last_error_info

PR-URL: https://github.com/nodejs/node/pull/13939
Fixes: https://github.com/nodejs/abi-stable-node/issues/251
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Hitesh Kanwathirtha <digitalinfinity@gmail.com>
---
 doc/api/n-api.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index f8154d2cb490ec..b1cf4d2306c435 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -269,7 +269,10 @@ Returns `napi_ok` if the API succeeded.
 This API retrieves a `napi_extended_error_info` structure with information
 about the last error that occured.
 
-**Note:** Do not rely on the content or format of any of the extended
+*Note*: The content of the `napi_extended_error_info` returned is only
+valid up until an n-api function is called on the same `env`.
+
+*Note*: Do not rely on the content or format of any of the extended
 information as it is not subject to SemVer and may change at any time.
 It is intended only for logging purposes.
 

From 947b1cd98b0c30bdb89a9bfc5798609e15f95d47 Mon Sep 17 00:00:00 2001
From: Kyle Farnung <kfarnung@microsoft.com>
Date: Wed, 28 Jun 2017 15:33:53 -0700
Subject: [PATCH 066/183] n-api: fix section title typo

PR-URL: https://github.com/nodejs/node/pull/13972
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Richard Lau <riclau@uk.ibm.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 doc/api/n-api.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index b1cf4d2306c435..233741d56b018b 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -41,7 +41,7 @@ The documentation for N-API is structured as follows:
 * [Working with JavaScript Properties][]
 * [Working with JavaScript Functions][]
 * [Object Wrap][]
-* [Aynchronous Operations][]
+* [Asynchronous Operations][]
 
 The N-API is a C API that ensures ABI stability across Node.js versions
 and different compiler levels. However, we also understand that a C++

From 922ea4634d770a06d9256be0842b496a7bf8b0a4 Mon Sep 17 00:00:00 2001
From: cjihrig <cjihrig@gmail.com>
Date: Wed, 28 Jun 2017 12:06:47 -0400
Subject: [PATCH 067/183] test: verify napi_get_property() walks prototype

Refs: https://github.com/nodejs/node/issues/13925
PR-URL: https://github.com/nodejs/node/pull/13961
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Evan Lucas <evanlucas@me.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 test/addons-napi/test_object/test.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/test/addons-napi/test_object/test.js b/test/addons-napi/test_object/test.js
index 4b64fa4b381af5..c9c549c827409f 100644
--- a/test/addons-napi/test_object/test.js
+++ b/test/addons-napi/test_object/test.js
@@ -31,6 +31,25 @@ assert(test_object.Has(newObject, 'test_number'));
 assert.strictEqual(newObject.test_number, 987654321);
 assert.strictEqual(newObject.test_string, 'test string');
 
+{
+  // Verify that napi_get_property() walks the prototype chain.
+  function MyObject() {
+    this.foo = 42;
+    this.bar = 43;
+  }
+
+  MyObject.prototype.bar = 44;
+  MyObject.prototype.baz = 45;
+
+  const obj = new MyObject();
+
+  assert.strictEqual(test_object.Get(obj, 'foo'), 42);
+  assert.strictEqual(test_object.Get(obj, 'bar'), 43);
+  assert.strictEqual(test_object.Get(obj, 'baz'), 45);
+  assert.strictEqual(test_object.Get(obj, 'toString'),
+                     Object.prototype.toString);
+}
+
 {
   // test_object.Inflate increases all properties by 1
   const cube = {

From ae0bdd592cfe3854e49ebfc1160e711341d0b940 Mon Sep 17 00:00:00 2001
From: cjihrig <cjihrig@gmail.com>
Date: Tue, 27 Jun 2017 13:29:58 -0400
Subject: [PATCH 068/183] n-api: add napi_delete_element()

Refs: https://github.com/nodejs/node/issues/13924
PR-URL: https://github.com/nodejs/node/pull/13949
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
---
 doc/api/n-api.md                         | 22 +++++++++++++++
 src/node_api.cc                          | 20 +++++++++++++
 src/node_api.h                           |  4 +++
 test/addons-napi/test_array/test.js      | 11 ++++++++
 test/addons-napi/test_array/test_array.c | 36 ++++++++++++++++++++++++
 5 files changed, 93 insertions(+)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 233741d56b018b..5c6654f97cfdd0 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -2400,6 +2400,27 @@ Returns `napi_ok` if the API succeeded.
 This API returns if the Object passed in has an element at the
 requested index.
 
+#### *napi_delete_element*
+<!-- YAML
+added: REPLACEME
+-->
+```C
+napi_status napi_delete_element(napi_env env,
+                                napi_value object,
+                                uint32_t index,
+                                bool* result);
+```
+
+- `[in] env`: The environment that the N-API call is invoked under.
+- `[in] object`: The object to query.
+- `[in] index`: The index of the property to delete.
+- `[out] result`: Whether the element deletion succeeded or not. `result` can
+optionally be ignored by passing `NULL`.
+
+Returns `napi_ok` if the API succeeded.
+
+This API attempts to delete the specified `index` from `object`.
+
 #### *napi_define_properties*
 <!-- YAML
 added: v8.0.0
@@ -3052,6 +3073,7 @@ support it:
 [`napi_define_class`]: #n_api_napi_define_class
 [`napi_delete_async_work`]: #n_api_napi_delete_async_work
 [`napi_define_class`]: #n_api_napi_define_class
+[`napi_delete_element`]: #n_api_napi_delete_element
 [`napi_delete_reference`]: #n_api_napi_delete_reference
 [`napi_escape_handle`]: #n_api_napi_escape_handle
 [`napi_get_array_length`]: #n_api_napi_get_array_length
diff --git a/src/node_api.cc b/src/node_api.cc
index 8cfaed7354626e..e182459cb8c5f4 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -1142,6 +1142,26 @@ napi_status napi_get_element(napi_env env,
   return GET_RETURN_STATUS(env);
 }
 
+napi_status napi_delete_element(napi_env env,
+                                napi_value object,
+                                uint32_t index,
+                                bool* result) {
+  NAPI_PREAMBLE(env);
+
+  v8::Isolate* isolate = env->isolate;
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Object> obj;
+
+  CHECK_TO_OBJECT(env, context, obj, object);
+  v8::Maybe<bool> delete_maybe = obj->Delete(context, index);
+  CHECK_MAYBE_NOTHING(env, delete_maybe, napi_generic_failure);
+
+  if (result != NULL)
+    *result = delete_maybe.FromMaybe(false);
+
+  return GET_RETURN_STATUS(env);
+}
+
 napi_status napi_define_properties(napi_env env,
                                    napi_value object,
                                    size_t property_count,
diff --git a/src/node_api.h b/src/node_api.h
index a1840943602ce3..58222e74318fe2 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -250,6 +250,10 @@ NAPI_EXTERN napi_status napi_get_element(napi_env env,
                                          napi_value object,
                                          uint32_t index,
                                          napi_value* result);
+NAPI_EXTERN napi_status napi_delete_element(napi_env env,
+                                            napi_value object,
+                                            uint32_t index,
+                                            bool* result);
 NAPI_EXTERN napi_status
 napi_define_properties(napi_env env,
                        napi_value object,
diff --git a/test/addons-napi/test_array/test.js b/test/addons-napi/test_array/test.js
index c1df4633b216fe..75c181d9da8269 100644
--- a/test/addons-napi/test_array/test.js
+++ b/test/addons-napi/test_array/test.js
@@ -47,3 +47,14 @@ assert(test_array.NewWithLength(0) instanceof Array);
 assert(test_array.NewWithLength(1) instanceof Array);
 // check max allowed length for an array 2^32 -1
 assert(test_array.NewWithLength(4294967295) instanceof Array);
+
+{
+  // Verify that array elements can be deleted.
+  const arr = ['a', 'b', 'c', 'd'];
+
+  assert.strictEqual(arr.length, 4);
+  assert.strictEqual(2 in arr, true);
+  assert.strictEqual(test_array.TestDeleteElement(arr, 2), true);
+  assert.strictEqual(arr.length, 4);
+  assert.strictEqual(2 in arr, false);
+}
diff --git a/test/addons-napi/test_array/test_array.c b/test/addons-napi/test_array/test_array.c
index ed1380efc99cde..4bb12d4e01e8fa 100644
--- a/test/addons-napi/test_array/test_array.c
+++ b/test/addons-napi/test_array/test_array.c
@@ -84,6 +84,41 @@ napi_value TestHasElement(napi_env env, napi_callback_info info) {
   return ret;
 }
 
+napi_value TestDeleteElement(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value args[2];
+
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+  NAPI_ASSERT(env, argc == 2, "Wrong number of arguments");
+
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
+  NAPI_ASSERT(env, valuetype0 == napi_object,
+    "Wrong type of arguments. Expects an array as first argument.");
+
+  napi_valuetype valuetype1;
+  NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
+  NAPI_ASSERT(env, valuetype1 == napi_number,
+    "Wrong type of arguments. Expects an integer as second argument.");
+
+  napi_value array = args[0];
+  int32_t index;
+  bool result;
+  napi_value ret;
+
+  NAPI_CALL(env, napi_get_value_int32(env, args[1], &index));
+  NAPI_CALL(env, napi_is_array(env, array, &result));
+
+  if (!result) {
+    return NULL;
+  }
+
+  NAPI_CALL(env, napi_delete_element(env, array, index, &result));
+  NAPI_CALL(env, napi_get_boolean(env, result, &ret));
+
+  return ret;
+}
+
 napi_value New(napi_env env, napi_callback_info info) {
   size_t argc = 1;
   napi_value args[1];
@@ -138,6 +173,7 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("TestGetElement", TestGetElement),
     DECLARE_NAPI_PROPERTY("TestHasElement", TestHasElement),
+    DECLARE_NAPI_PROPERTY("TestDeleteElement", TestDeleteElement),
     DECLARE_NAPI_PROPERTY("New", New),
     DECLARE_NAPI_PROPERTY("NewWithLength", NewWithLength),
   };

From 22b9a87845a17492a955ea2d3ab1a0558429b509 Mon Sep 17 00:00:00 2001
From: cjihrig <cjihrig@gmail.com>
Date: Mon, 26 Jun 2017 14:31:55 -0400
Subject: [PATCH 069/183] n-api: add napi_delete_property()

Fixes: https://github.com/nodejs/node/issues/13924
PR-URL: https://github.com/nodejs/node/pull/13934
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
---
 doc/api/n-api.md                           | 23 +++++++++++
 src/node_api.cc                            | 22 +++++++++++
 src/node_api.h                             |  4 ++
 test/addons-napi/test_object/test.js       | 44 ++++++++++++++++++++++
 test/addons-napi/test_object/test_object.c | 26 +++++++++++++
 5 files changed, 119 insertions(+)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 5c6654f97cfdd0..831a02cf3dfa82 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -2276,6 +2276,28 @@ Returns `napi_ok` if the API succeeded.
 This API checks if the Object passed in has the named property.
 
 
+#### *napi_delete_property*
+<!-- YAML
+added: REPLACEME
+-->
+```C
+napi_status napi_delete_property(napi_env env,
+                                 napi_value object,
+                                 napi_value key,
+                                 bool* result);
+```
+
+- `[in] env`: The environment that the N-API call is invoked under.
+- `[in] object`: The object to query.
+- `[in] key`: The name of the property to delete.
+- `[out] result`: Whether the property deletion succeeded or not. `result` can
+optionally be ignored by passing `NULL`.
+
+Returns `napi_ok` if the API succeeded.
+
+This API attempts to delete the `key` own property from `object`.
+
+
 #### *napi_set_named_property*
 <!-- YAML
 added: v8.0.0
@@ -3074,6 +3096,7 @@ support it:
 [`napi_delete_async_work`]: #n_api_napi_delete_async_work
 [`napi_define_class`]: #n_api_napi_define_class
 [`napi_delete_element`]: #n_api_napi_delete_element
+[`napi_delete_property`]: #n_api_napi_delete_property
 [`napi_delete_reference`]: #n_api_napi_delete_reference
 [`napi_escape_handle`]: #n_api_napi_escape_handle
 [`napi_get_array_length`]: #n_api_napi_get_array_length
diff --git a/src/node_api.cc b/src/node_api.cc
index e182459cb8c5f4..ef02bd47f6e549 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -1005,6 +1005,28 @@ napi_status napi_get_property(napi_env env,
   return GET_RETURN_STATUS(env);
 }
 
+napi_status napi_delete_property(napi_env env,
+                                 napi_value object,
+                                 napi_value key,
+                                 bool* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(env, key);
+
+  v8::Isolate* isolate = env->isolate;
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Value> k = v8impl::V8LocalValueFromJsValue(key);
+  v8::Local<v8::Object> obj;
+
+  CHECK_TO_OBJECT(env, context, obj, object);
+  v8::Maybe<bool> delete_maybe = obj->Delete(context, k);
+  CHECK_MAYBE_NOTHING(env, delete_maybe, napi_generic_failure);
+
+  if (result != NULL)
+    *result = delete_maybe.FromMaybe(false);
+
+  return GET_RETURN_STATUS(env);
+}
+
 napi_status napi_set_named_property(napi_env env,
                                     napi_value object,
                                     const char* utf8name,
diff --git a/src/node_api.h b/src/node_api.h
index 58222e74318fe2..503ea258881cad 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -226,6 +226,10 @@ NAPI_EXTERN napi_status napi_get_property(napi_env env,
                                           napi_value object,
                                           napi_value key,
                                           napi_value* result);
+NAPI_EXTERN napi_status napi_delete_property(napi_env env,
+                                             napi_value object,
+                                             napi_value key,
+                                             bool* result);
 NAPI_EXTERN napi_status napi_set_named_property(napi_env env,
                                           napi_value object,
                                           const char* utf8name,
diff --git a/test/addons-napi/test_object/test.js b/test/addons-napi/test_object/test.js
index c9c549c827409f..fe6fb169b6c701 100644
--- a/test/addons-napi/test_object/test.js
+++ b/test/addons-napi/test_object/test.js
@@ -120,3 +120,47 @@ assert.strictEqual(newObject.test_string, 'test string');
   assert(wrapper.protoA, true);
   assert(wrapper.protoB, true);
 }
+
+{
+  // Verify that normal and nonexistent properties can be deleted.
+  const sym = Symbol();
+  const obj = { foo: 'bar', [sym]: 'baz' };
+
+  assert.strictEqual('foo' in obj, true);
+  assert.strictEqual(sym in obj, true);
+  assert.strictEqual('does_not_exist' in obj, false);
+  assert.strictEqual(test_object.Delete(obj, 'foo'), true);
+  assert.strictEqual('foo' in obj, false);
+  assert.strictEqual(sym in obj, true);
+  assert.strictEqual('does_not_exist' in obj, false);
+  assert.strictEqual(test_object.Delete(obj, sym), true);
+  assert.strictEqual('foo' in obj, false);
+  assert.strictEqual(sym in obj, false);
+  assert.strictEqual('does_not_exist' in obj, false);
+}
+
+{
+  // Verify that non-configurable properties are not deleted.
+  const obj = {};
+
+  Object.defineProperty(obj, 'foo', { configurable: false });
+  assert.strictEqual(test_object.Delete(obj, 'foo'), false);
+  assert.strictEqual('foo' in obj, true);
+}
+
+{
+  // Verify that prototype properties are not deleted.
+  function Foo() {
+    this.foo = 'bar';
+  }
+
+  Foo.prototype.foo = 'baz';
+
+  const obj = new Foo();
+
+  assert.strictEqual(obj.foo, 'bar');
+  assert.strictEqual(test_object.Delete(obj, 'foo'), true);
+  assert.strictEqual(obj.foo, 'baz');
+  assert.strictEqual(test_object.Delete(obj, 'foo'), true);
+  assert.strictEqual(obj.foo, 'baz');
+}
diff --git a/test/addons-napi/test_object/test_object.c b/test/addons-napi/test_object/test_object.c
index 383fe46342a340..ad24d61ca787e0 100644
--- a/test/addons-napi/test_object/test_object.c
+++ b/test/addons-napi/test_object/test_object.c
@@ -86,6 +86,31 @@ napi_value Has(napi_env env, napi_callback_info info) {
   return ret;
 }
 
+napi_value Delete(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value args[2];
+
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+  NAPI_ASSERT(env, argc == 2, "Wrong number of arguments");
+
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
+  NAPI_ASSERT(env, valuetype0 == napi_object,
+    "Wrong type of arguments. Expects an object as first argument.");
+
+  napi_valuetype valuetype1;
+  NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
+  NAPI_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
+    "Wrong type of arguments. Expects a string or symbol as second.");
+
+  bool result;
+  napi_value ret;
+  NAPI_CALL(env, napi_delete_property(env, args[0], args[1], &result));
+  NAPI_CALL(env, napi_get_boolean(env, result, &ret));
+
+  return ret;
+}
+
 napi_value New(napi_env env, napi_callback_info info) {
   napi_value ret;
   NAPI_CALL(env, napi_create_object(env, &ret));
@@ -171,6 +196,7 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("Get", Get),
     DECLARE_NAPI_PROPERTY("Set", Set),
     DECLARE_NAPI_PROPERTY("Has", Has),
+    DECLARE_NAPI_PROPERTY("Delete", Delete),
     DECLARE_NAPI_PROPERTY("New", New),
     DECLARE_NAPI_PROPERTY("Inflate", Inflate),
     DECLARE_NAPI_PROPERTY("Wrap", Wrap),

From c95b561582a1506a0b38917107938ae905bb78df Mon Sep 17 00:00:00 2001
From: Ben Noordhuis <info@bnoordhuis.nl>
Date: Mon, 3 Jul 2017 12:07:16 +0200
Subject: [PATCH 070/183] n-api: use Maybe version of Object::SetPrototype()
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Fixes the following deprecation warning:

    ../src/node_api.cc:2020:30: warning: 'bool
    v8::Object::SetPrototype(v8::Local<v8::Value>)' is deprecated: Use
    maybe version [-Wdeprecated-declarations]
       wrapper->SetPrototype(proto);
    ../src/node_api.cc:2021:28: warning: 'bool
    v8::Object::SetPrototype(v8::Local<v8::Value>)' is deprecated: Use
    maybe version [-Wdeprecated-declarations]
       obj->SetPrototype(wrapper);

PR-URL: https://github.com/nodejs/node/pull/14053
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
---
 src/node_api.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index ef02bd47f6e549..f0dbe1fb717486 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -2020,8 +2020,8 @@ napi_status napi_wrap(napi_env env,
 
   // Insert the wrapper into the object's prototype chain.
   v8::Local<v8::Value> proto = obj->GetPrototype();
-  wrapper->SetPrototype(proto);
-  obj->SetPrototype(wrapper);
+  CHECK(wrapper->SetPrototype(context, proto).FromJust());
+  CHECK(obj->SetPrototype(context, wrapper).FromJust());
 
   if (result != nullptr) {
     // The returned reference should be deleted via napi_delete_reference()

From c5c580c29690b84cb0a612740bb4e1fcebee4484 Mon Sep 17 00:00:00 2001
From: Ben Noordhuis <info@bnoordhuis.nl>
Date: Mon, 3 Jul 2017 12:11:35 +0200
Subject: [PATCH 071/183] n-api: fix -Wmaybe-uninitialized compiler warning
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Not an actual bug, as far as I can tell, the compiler is simply not
smart enough to figure out that the offending code path isn't reached
with an uninitialized value.

PR-URL: https://github.com/nodejs/node/pull/14053
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
---
 src/node_api.cc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index f0dbe1fb717486..1cd2fad9b9807a 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -2326,7 +2326,7 @@ napi_status napi_instanceof(napi_env env,
   }
 
   if (env->has_instance_available) {
-    napi_value value, js_result, has_instance = nullptr;
+    napi_value value, js_result = nullptr, has_instance = nullptr;
     napi_status status = napi_generic_failure;
     napi_valuetype value_type;
 

From 134d7a12f487ca767b4e437ea65a042f91f5c477 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Thu, 29 Jun 2017 13:07:03 -0400
Subject: [PATCH 072/183] test: add coverage for napi_typeof

We had some, but not complete coverage indirectly through
other tests.  Add test to validate it specifically and
covers cases that were not being covered.

PR-URL: https://github.com/nodejs/node/pull/13990
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 test/addons-napi/test_general/test.js        | 16 ++++++++++
 test/addons-napi/test_general/test_general.c | 32 +++++++++++++++++++-
 2 files changed, 47 insertions(+), 1 deletion(-)

diff --git a/test/addons-napi/test_general/test.js b/test/addons-napi/test_general/test.js
index 614cf0f4f0e7c4..a5d40c50384709 100644
--- a/test/addons-napi/test_general/test.js
+++ b/test/addons-napi/test_general/test.js
@@ -34,3 +34,19 @@ assert.ok(test_general.testGetPrototype(baseObject) !==
 // test version management funcitons
 // expected version is currently 1
 assert.strictEqual(test_general.testGetVersion(), 1);
+
+[
+  123,
+  'test string',
+  function() {},
+  new Object(),
+  true,
+  undefined,
+  Symbol()
+].forEach((val) => {
+  assert.strictEqual(test_general.testNapiTypeof(val), typeof val);
+});
+
+// since typeof in js return object need to validate specific case
+// for null
+assert.strictEqual(test_general.testNapiTypeof(null), 'null');
diff --git a/test/addons-napi/test_general/test_general.c b/test/addons-napi/test_general/test_general.c
index 0b69cc41e29fb5..ab2428b97528ee 100644
--- a/test/addons-napi/test_general/test_general.c
+++ b/test/addons-napi/test_general/test_general.c
@@ -29,7 +29,7 @@ napi_value testGetVersion(napi_env env, napi_callback_info info) {
   uint32_t version;
   napi_value result;
   NAPI_CALL(env, napi_get_version(env, &version));
-  NAPI_CALL(env ,napi_create_number(env, version, &result));
+  NAPI_CALL(env, napi_create_number(env, version, &result));
   return result;
 }
 
@@ -90,6 +90,35 @@ napi_value testNapiErrorCleanup(napi_env env, napi_callback_info info) {
   return result;
 }
 
+napi_value testNapiTypeof(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  napi_valuetype argument_type;
+  NAPI_CALL(env, napi_typeof(env, args[0], &argument_type));
+
+  napi_value result;
+  if (argument_type == napi_number) {
+    NAPI_CALL(env, napi_create_string_utf8(env, "number", -1, &result));
+  } else if (argument_type == napi_string) {
+    NAPI_CALL(env, napi_create_string_utf8(env, "string", -1, &result));
+  } else if (argument_type == napi_function) {
+    NAPI_CALL(env, napi_create_string_utf8(env, "function", -1, &result));
+  } else if (argument_type == napi_object) {
+    NAPI_CALL(env, napi_create_string_utf8(env, "object", -1, &result));
+  } else if (argument_type == napi_boolean) {
+    NAPI_CALL(env, napi_create_string_utf8(env, "boolean", -1, &result));
+  } else if (argument_type == napi_undefined) {
+    NAPI_CALL(env, napi_create_string_utf8(env, "undefined", -1, &result));
+  } else if (argument_type == napi_symbol) {
+    NAPI_CALL(env, napi_create_string_utf8(env, "symbol", -1, &result));
+  } else if (argument_type == napi_null) {
+    NAPI_CALL(env, napi_create_string_utf8(env, "null", -1, &result));
+  }
+  return result;
+}
+
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("testStrictEquals", testStrictEquals),
@@ -100,6 +129,7 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("getNull", getNull),
     DECLARE_NAPI_PROPERTY("createNapiError", createNapiError),
     DECLARE_NAPI_PROPERTY("testNapiErrorCleanup", testNapiErrorCleanup),
+    DECLARE_NAPI_PROPERTY("testNapiTypeof", testNapiTypeof),
   };
 
   NAPI_CALL_RETURN_VOID(env, napi_define_properties(

From 35b3c61470fce2f477b80f7a183a856655d5f132 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Fri, 30 Jun 2017 13:46:25 +0300
Subject: [PATCH 073/183] N-API: Reuse ObjectTemplate instances

V8 caches and does not subsequently release `ObjectTemplate` instances.
Thus, we need to store the `ObjectTemplate` from which we derive object
instances we use for `napi_wrap()` and function/accessor context in a
persistent in the `napi_env`.

https://github.com/nodejs/node-addon-api/pull/70#discussion_r124998408

PR-URL: https://github.com/nodejs/node/pull/13999
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.co>
Reviewed-By: Hitesh Kanwathirtha <digitalinfinity@gmail.com>
---
 src/node_api.cc | 33 +++++++++++++++++++++++++--------
 1 file changed, 25 insertions(+), 8 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 1cd2fad9b9807a..addd63a0f7e6f3 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -36,14 +36,32 @@ struct napi_env__ {
   ~napi_env__() {
     last_exception.Reset();
     has_instance.Reset();
+    wrap_template.Reset();
+    function_data_template.Reset();
+    accessor_data_template.Reset();
   }
   v8::Isolate* isolate;
   v8::Persistent<v8::Value> last_exception;
   v8::Persistent<v8::Value> has_instance;
+  v8::Persistent<v8::ObjectTemplate> wrap_template;
+  v8::Persistent<v8::ObjectTemplate> function_data_template;
+  v8::Persistent<v8::ObjectTemplate> accessor_data_template;
   bool has_instance_available;
   napi_extended_error_info last_error;
 };
 
+#define ENV_OBJECT_TEMPLATE(env, prefix, destination, field_count) \
+  do {                                                             \
+    if ((env)->prefix ## _template.IsEmpty()) {                    \
+      (destination) = v8::ObjectTemplate::New(isolate);            \
+      (destination)->SetInternalFieldCount((field_count));         \
+      (env)->prefix ## _template.Reset(isolate, (destination));    \
+    } else {                                                       \
+      (destination) = env->prefix ## _template.Get(isolate);       \
+    }                                                              \
+  } while (0)
+
+
 #define RETURN_STATUS_IF_FALSE(env, condition, status)                  \
   do {                                                                  \
     if (!(condition)) {                                                 \
@@ -608,8 +626,8 @@ v8::Local<v8::Object> CreateFunctionCallbackData(napi_env env,
   v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
 
-  v8::Local<v8::ObjectTemplate> otpl = v8::ObjectTemplate::New(isolate);
-  otpl->SetInternalFieldCount(v8impl::kFunctionFieldCount);
+  v8::Local<v8::ObjectTemplate> otpl;
+  ENV_OBJECT_TEMPLATE(env, function_data, otpl, v8impl::kFunctionFieldCount);
   v8::Local<v8::Object> cbdata = otpl->NewInstance(context).ToLocalChecked();
 
   cbdata->SetInternalField(
@@ -634,8 +652,8 @@ v8::Local<v8::Object> CreateAccessorCallbackData(napi_env env,
   v8::Isolate* isolate = env->isolate;
   v8::Local<v8::Context> context = isolate->GetCurrentContext();
 
-  v8::Local<v8::ObjectTemplate> otpl = v8::ObjectTemplate::New(isolate);
-  otpl->SetInternalFieldCount(v8impl::kAccessorFieldCount);
+  v8::Local<v8::ObjectTemplate> otpl;
+  ENV_OBJECT_TEMPLATE(env, accessor_data, otpl, v8impl::kAccessorFieldCount);
   v8::Local<v8::Object> cbdata = otpl->NewInstance(context).ToLocalChecked();
 
   cbdata->SetInternalField(
@@ -2011,11 +2029,10 @@ napi_status napi_wrap(napi_env env,
   v8::Local<v8::Object> obj = value.As<v8::Object>();
 
   // Create a wrapper object with an internal field to hold the wrapped pointer.
-  v8::Local<v8::ObjectTemplate> wrapperTemplate =
-    v8::ObjectTemplate::New(isolate);
-  wrapperTemplate->SetInternalFieldCount(1);
+  v8::Local<v8::ObjectTemplate> wrapper_template;
+  ENV_OBJECT_TEMPLATE(env, wrap, wrapper_template, 1);
   v8::Local<v8::Object> wrapper =
-    wrapperTemplate->NewInstance(context).ToLocalChecked();
+      wrapper_template->NewInstance(context).ToLocalChecked();
   wrapper->SetInternalField(0, v8::External::New(isolate, native_object));
 
   // Insert the wrapper into the object's prototype chain.

From bb5a56e494f333bb37248d98df7f77a06cf29e00 Mon Sep 17 00:00:00 2001
From: cjihrig <cjihrig@gmail.com>
Date: Mon, 3 Jul 2017 15:06:46 -0400
Subject: [PATCH 074/183] n-api: add napi_has_own_property()

Refs: https://github.com/nodejs/node/issues/13925
PR-URL: https://github.com/nodejs/node/pull/14063
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
---
 doc/api/n-api.md                           | 24 +++++++++++++++
 src/node_api.cc                            | 21 +++++++++++++
 src/node_api.h                             |  4 +++
 test/addons-napi/test_object/test.js       | 34 ++++++++++++++++++++++
 test/addons-napi/test_object/test_object.c | 29 ++++++++++++++++++
 5 files changed, 112 insertions(+)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 831a02cf3dfa82..b35a99f5c46021 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -2298,6 +2298,29 @@ Returns `napi_ok` if the API succeeded.
 This API attempts to delete the `key` own property from `object`.
 
 
+#### *napi_has_own_property*
+<!-- YAML
+added: REPLACEME
+-->
+```C
+napi_status napi_has_own_property(napi_env env,
+                                  napi_value object,
+                                  napi_value key,
+                                  bool* result);
+```
+
+- `[in] env`: The environment that the N-API call is invoked under.
+- `[in] object`: The object to query.
+- `[in] key`: The name of the own property whose existence to check.
+- `[out] result`: Whether the own property exists on the object or not.
+
+Returns `napi_ok` if the API succeeded.
+
+This API checks if the Object passed in has the named own property. `key` must
+be a string or a Symbol, or an error will be thrown. N-API will not perform any
+conversion between data types.
+
+
 #### *napi_set_named_property*
 <!-- YAML
 added: v8.0.0
@@ -3103,6 +3126,7 @@ support it:
 [`napi_get_element`]: #n_api_napi_get_element
 [`napi_get_property`]: #n_api_napi_get_property
 [`napi_has_property`]: #n_api_napi_has_property
+[`napi_has_own_property`]: #n_api_napi_has_own_property
 [`napi_set_property`]: #n_api_napi_set_property
 [`napi_get_reference_value`]: #n_api_napi_get_reference_value
 [`napi_is_error`]: #n_api_napi_is_error
diff --git a/src/node_api.cc b/src/node_api.cc
index addd63a0f7e6f3..b857c7fa2d8246 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -1045,6 +1045,27 @@ napi_status napi_delete_property(napi_env env,
   return GET_RETURN_STATUS(env);
 }
 
+NAPI_EXTERN napi_status napi_has_own_property(napi_env env,
+                                              napi_value object,
+                                              napi_value key,
+                                              bool* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(env, key);
+
+  v8::Isolate* isolate = env->isolate;
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Object> obj;
+
+  CHECK_TO_OBJECT(env, context, obj, object);
+  v8::Local<v8::Value> k = v8impl::V8LocalValueFromJsValue(key);
+  RETURN_STATUS_IF_FALSE(env, k->IsName(), napi_name_expected);
+  v8::Maybe<bool> has_maybe = obj->HasOwnProperty(context, k.As<v8::Name>());
+  CHECK_MAYBE_NOTHING(env, has_maybe, napi_generic_failure);
+  *result = has_maybe.FromMaybe(false);
+
+  return GET_RETURN_STATUS(env);
+}
+
 napi_status napi_set_named_property(napi_env env,
                                     napi_value object,
                                     const char* utf8name,
diff --git a/src/node_api.h b/src/node_api.h
index 503ea258881cad..e346b762dd2702 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -230,6 +230,10 @@ NAPI_EXTERN napi_status napi_delete_property(napi_env env,
                                              napi_value object,
                                              napi_value key,
                                              bool* result);
+NAPI_EXTERN napi_status napi_has_own_property(napi_env env,
+                                              napi_value object,
+                                              napi_value key,
+                                              bool* result);
 NAPI_EXTERN napi_status napi_set_named_property(napi_env env,
                                           napi_value object,
                                           const char* utf8name,
diff --git a/test/addons-napi/test_object/test.js b/test/addons-napi/test_object/test.js
index fe6fb169b6c701..9e8f17de28287c 100644
--- a/test/addons-napi/test_object/test.js
+++ b/test/addons-napi/test_object/test.js
@@ -50,6 +50,40 @@ assert.strictEqual(newObject.test_string, 'test string');
                      Object.prototype.toString);
 }
 
+{
+  // Verify that napi_has_own_property() fails if property is not a name.
+  [true, false, null, undefined, {}, [], 0, 1, () => {}].forEach((value) => {
+    assert.throws(() => {
+      test_object.HasOwn({}, value);
+    }, /^Error: A string or symbol was expected$/);
+  });
+}
+
+{
+  // Verify that napi_has_own_property() does not walk the prototype chain.
+  const symbol1 = Symbol();
+  const symbol2 = Symbol();
+
+  function MyObject() {
+    this.foo = 42;
+    this.bar = 43;
+    this[symbol1] = 44;
+  }
+
+  MyObject.prototype.bar = 45;
+  MyObject.prototype.baz = 46;
+  MyObject.prototype[symbol2] = 47;
+
+  const obj = new MyObject();
+
+  assert.strictEqual(test_object.HasOwn(obj, 'foo'), true);
+  assert.strictEqual(test_object.HasOwn(obj, 'bar'), true);
+  assert.strictEqual(test_object.HasOwn(obj, symbol1), true);
+  assert.strictEqual(test_object.HasOwn(obj, 'baz'), false);
+  assert.strictEqual(test_object.HasOwn(obj, 'toString'), false);
+  assert.strictEqual(test_object.HasOwn(obj, symbol2), false);
+}
+
 {
   // test_object.Inflate increases all properties by 1
   const cube = {
diff --git a/test/addons-napi/test_object/test_object.c b/test/addons-napi/test_object/test_object.c
index ad24d61ca787e0..96a7aa9c205ccf 100644
--- a/test/addons-napi/test_object/test_object.c
+++ b/test/addons-napi/test_object/test_object.c
@@ -86,6 +86,34 @@ napi_value Has(napi_env env, napi_callback_info info) {
   return ret;
 }
 
+napi_value HasOwn(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value args[2];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc == 2, "Wrong number of arguments");
+
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
+
+  NAPI_ASSERT(env, valuetype0 == napi_object,
+    "Wrong type of arguments. Expects an object as first argument.");
+
+  // napi_valuetype valuetype1;
+  // NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
+  //
+  // NAPI_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
+  //   "Wrong type of arguments. Expects a string or symbol as second.");
+
+  bool has_property;
+  NAPI_CALL(env, napi_has_own_property(env, args[0], args[1], &has_property));
+
+  napi_value ret;
+  NAPI_CALL(env, napi_get_boolean(env, has_property, &ret));
+
+  return ret;
+}
+
 napi_value Delete(napi_env env, napi_callback_info info) {
   size_t argc = 2;
   napi_value args[2];
@@ -196,6 +224,7 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("Get", Get),
     DECLARE_NAPI_PROPERTY("Set", Set),
     DECLARE_NAPI_PROPERTY("Has", Has),
+    DECLARE_NAPI_PROPERTY("HasOwn", HasOwn),
     DECLARE_NAPI_PROPERTY("Delete", Delete),
     DECLARE_NAPI_PROPERTY("New", New),
     DECLARE_NAPI_PROPERTY("Inflate", Inflate),

From c8ae23e57f9120b9a041c34b263ca4b04ea0dddd Mon Sep 17 00:00:00 2001
From: Daniel Bevenius <daniel.bevenius@gmail.com>
Date: Thu, 6 Jul 2017 14:30:54 +0200
Subject: [PATCH 075/183] n-api: fix warning in test_general

Currently the following warning is issued when buildning:

Building addon
/work/nodejs/node/test/addons-napi/test_general/
  CC(target) Debug/obj.target/test_general/test_general.o
../test_general.c:116:14: warning: variable 'result' is used
uninitialized whenever 'if' condition is false
[-Wsometimes-uninitialized]
  } else if (argument_type == napi_null) {
             ^~~~~~~~~~~~~~~~~~~~~~~~~~
../test_general.c:119:10: note: uninitialized use occurs here
  return result;
         ^~~~~~
../test_general.c:116:10: note: remove the 'if' if its condition is
always true
  } else if (argument_type == napi_null) {
         ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
../test_general.c:101:20: note: initialize the variable 'result' to
silence this warning
  napi_value result;
                   ^
                    = NULL

This commit simply initializes result to NULL to avoid this warning.

PR-URL: https://github.com/nodejs/node/pull/14104
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 test/addons-napi/test_general/test_general.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/addons-napi/test_general/test_general.c b/test/addons-napi/test_general/test_general.c
index ab2428b97528ee..bbf7684676aace 100644
--- a/test/addons-napi/test_general/test_general.c
+++ b/test/addons-napi/test_general/test_general.c
@@ -98,7 +98,7 @@ napi_value testNapiTypeof(napi_env env, napi_callback_info info) {
   napi_valuetype argument_type;
   NAPI_CALL(env, napi_typeof(env, args[0], &argument_type));
 
-  napi_value result;
+  napi_value result = NULL;
   if (argument_type == napi_number) {
     NAPI_CALL(env, napi_create_string_utf8(env, "number", -1, &result));
   } else if (argument_type == napi_string) {

From 99fc87e07042bcc23bf09bf1b05ca9c730b91e88 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Thu, 22 Jun 2017 14:10:05 +0300
Subject: [PATCH 076/183] n-api: Implement stricter wrapping

Use a stronger criterion to identify objects in the prototype chain that store
pointers to native data that were added by previous calls to `napi_wrap()`.

Whereas the old criterion for identifying `napi_wrap()`-injected prototype
chain objects was to consider an object with an internal field
count of 1 to be such an object, the new criterion is to consider an object
with an internal field count of 2 such that the second field holds a
`v8::External` which itself contains a pointer to a global static string unique
to N-API to be a `napi_wrap()`-injected prototype chain object.

This greatly reduces the possibility of returning a pointer that was not
previously added with `napi_wrap()`, and it allows us to recognize that an
object has already undergone `napi_wrap()` and we can thus prevent a chain of
wrappers only the first of which is accessible from appearing in the prototype
chain, as would be the result of multiple calls to `napi_wrap()` using the same
object.

PR-URL: https://github.com/nodejs/node/pull/13872
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
---
 doc/api/n-api.md                             |  8 ++-
 src/node_api.cc                              | 64 +++++++++++++++-----
 test/addons-napi/test_general/test.js        |  8 +++
 test/addons-napi/test_general/test_general.c | 19 ++++++
 4 files changed, 83 insertions(+), 16 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index b35a99f5c46021..8063eaf7348dc0 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -2876,8 +2876,8 @@ napi_status napi_wrap(napi_env env,
 
 Returns `napi_ok` if the API succeeded.
 
-Wraps a native instance in JavaScript object of the corresponding type.
-The native instance can be retrieved later using `napi_unwrap()`.
+Wraps a native instance in a JavaScript object. The native instance can be
+retrieved later using `napi_unwrap()`.
 
 When JavaScript code invokes a constructor for a class that was defined using
 `napi_define_class()`, the `napi_callback` for the constructor is invoked.
@@ -2905,6 +2905,10 @@ required in order to enable correct proper of the reference.
 Afterward, additional manipulation of the wrapper's prototype chain may cause
 `napi_unwrap()` to fail.
 
+*Note*: Calling `napi_wrap()` a second time on an object that already has a
+native instance associated with it by virtue of a previous call to
+`napi_wrap()` will cause an error to be returned.
+
 ### *napi_unwrap*
 <!-- YAML
 added: v8.0.0
diff --git a/src/node_api.cc b/src/node_api.cc
index b857c7fa2d8246..fee00dabe9a14d 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -678,6 +678,38 @@ v8::Local<v8::Object> CreateAccessorCallbackData(napi_env env,
   return cbdata;
 }
 
+// Pointer used to identify items wrapped by N-API. Used by FindWrapper and
+// napi_wrap().
+const char napi_wrap_name[] = "N-API Wrapper";
+
+// Search the object's prototype chain for the wrapper object. Usually the
+// wrapper would be the first in the chain, but it is OK for other objects to
+// be inserted in the prototype chain.
+bool FindWrapper(v8::Local<v8::Object> obj,
+                 v8::Local<v8::Object>* result = nullptr) {
+  v8::Local<v8::Object> wrapper = obj;
+
+  do {
+    v8::Local<v8::Value> proto = wrapper->GetPrototype();
+    if (proto.IsEmpty() || !proto->IsObject()) {
+      return false;
+    }
+    wrapper = proto.As<v8::Object>();
+    if (wrapper->InternalFieldCount() == 2) {
+      v8::Local<v8::Value> external = wrapper->GetInternalField(1);
+      if (external->IsExternal() &&
+          external.As<v8::External>()->Value() == v8impl::napi_wrap_name) {
+        break;
+      }
+    }
+  } while (true);
+
+  if (result != nullptr) {
+    *result = wrapper;
+  }
+  return true;
+}
+
 }  // end of namespace v8impl
 
 // Intercepts the Node-V8 module registration callback. Converts parameters
@@ -2049,11 +2081,22 @@ napi_status napi_wrap(napi_env env,
   RETURN_STATUS_IF_FALSE(env, value->IsObject(), napi_invalid_arg);
   v8::Local<v8::Object> obj = value.As<v8::Object>();
 
-  // Create a wrapper object with an internal field to hold the wrapped pointer.
+  // If we've already wrapped this object, we error out.
+  RETURN_STATUS_IF_FALSE(env, !v8impl::FindWrapper(obj), napi_invalid_arg);
+
+  // Create a wrapper object with an internal field to hold the wrapped pointer
+  // and a second internal field to identify the owner as N-API.
   v8::Local<v8::ObjectTemplate> wrapper_template;
-  ENV_OBJECT_TEMPLATE(env, wrap, wrapper_template, 1);
-  v8::Local<v8::Object> wrapper =
-      wrapper_template->NewInstance(context).ToLocalChecked();
+  ENV_OBJECT_TEMPLATE(env, wrap, wrapper_template, 2);
+
+  auto maybe_object = wrapper_template->NewInstance(context);
+  CHECK_MAYBE_EMPTY(env, maybe_object, napi_generic_failure);
+
+  v8::Local<v8::Object> wrapper = maybe_object.ToLocalChecked();
+  wrapper->SetInternalField(1, v8::External::New(isolate,
+    reinterpret_cast<void*>(const_cast<char*>(v8impl::napi_wrap_name))));
+
+  // Store the pointer as an external in the wrapper.
   wrapper->SetInternalField(0, v8::External::New(isolate, native_object));
 
   // Insert the wrapper into the object's prototype chain.
@@ -2090,16 +2133,9 @@ napi_status napi_unwrap(napi_env env, napi_value js_object, void** result) {
   RETURN_STATUS_IF_FALSE(env, value->IsObject(), napi_invalid_arg);
   v8::Local<v8::Object> obj = value.As<v8::Object>();
 
-  // Search the object's prototype chain for the wrapper with an internal field.
-  // Usually the wrapper would be the first in the chain, but it is OK for
-  // other objects to be inserted in the prototype chain.
-  v8::Local<v8::Object> wrapper = obj;
-  do {
-    v8::Local<v8::Value> proto = wrapper->GetPrototype();
-    RETURN_STATUS_IF_FALSE(
-      env, !proto.IsEmpty() && proto->IsObject(), napi_invalid_arg);
-    wrapper = proto.As<v8::Object>();
-  } while (wrapper->InternalFieldCount() != 1);
+  v8::Local<v8::Object> wrapper;
+  RETURN_STATUS_IF_FALSE(
+    env, v8impl::FindWrapper(obj, &wrapper), napi_invalid_arg);
 
   v8::Local<v8::Value> unwrappedValue = wrapper->GetInternalField(0);
   RETURN_STATUS_IF_FALSE(env, unwrappedValue->IsExternal(), napi_invalid_arg);
diff --git a/test/addons-napi/test_general/test.js b/test/addons-napi/test_general/test.js
index a5d40c50384709..36610af8c8c15f 100644
--- a/test/addons-napi/test_general/test.js
+++ b/test/addons-napi/test_general/test.js
@@ -50,3 +50,11 @@ assert.strictEqual(test_general.testGetVersion(), 1);
 // since typeof in js return object need to validate specific case
 // for null
 assert.strictEqual(test_general.testNapiTypeof(null), 'null');
+
+const x = {};
+
+// Assert that wrapping twice fails.
+test_general.wrap(x, 25);
+assert.throws(function() {
+  test_general.wrap(x, 'Blah');
+}, Error);
diff --git a/test/addons-napi/test_general/test_general.c b/test/addons-napi/test_general/test_general.c
index bbf7684676aace..2d2d13a3624e6e 100644
--- a/test/addons-napi/test_general/test_general.c
+++ b/test/addons-napi/test_general/test_general.c
@@ -119,6 +119,24 @@ napi_value testNapiTypeof(napi_env env, napi_callback_info info) {
   return result;
 }
 
+static void deref_item(napi_env env, void* data, void* hint) {
+  (void) hint;
+
+  NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, (napi_ref)data));
+}
+
+napi_value wrap(napi_env env, napi_callback_info info) {
+  size_t argc = 2;
+  napi_value argv[2];
+  napi_ref payload;
+
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+  NAPI_CALL(env, napi_create_reference(env, argv[1], 1, &payload));
+  NAPI_CALL(env, napi_wrap(env, argv[0], payload, deref_item, NULL, NULL));
+
+  return NULL;
+}
+
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("testStrictEquals", testStrictEquals),
@@ -130,6 +148,7 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("createNapiError", createNapiError),
     DECLARE_NAPI_PROPERTY("testNapiErrorCleanup", testNapiErrorCleanup),
     DECLARE_NAPI_PROPERTY("testNapiTypeof", testNapiTypeof),
+    DECLARE_NAPI_PROPERTY("wrap", wrap),
   };
 
   NAPI_CALL_RETURN_VOID(env, napi_define_properties(

From 1536f376a30d893ebd2d73f7a47aa7f83bf00783 Mon Sep 17 00:00:00 2001
From: Kyle Farnung <kfarnung@microsoft.com>
Date: Wed, 5 Jul 2017 14:39:06 -0700
Subject: [PATCH 077/183] n-api: wrap test macros in do/while

PR-URL: https://github.com/nodejs/node/pull/14095
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/addons-napi/common.h                     | 26 +++++++++++--------
 test/addons-napi/test_object/test_object.c    |  2 +-
 .../test_reference/test_reference.c           |  4 +--
 3 files changed, 18 insertions(+), 14 deletions(-)

diff --git a/test/addons-napi/common.h b/test/addons-napi/common.h
index eae2d48b04459c..e9640935d4154b 100644
--- a/test/addons-napi/common.h
+++ b/test/addons-napi/common.h
@@ -14,15 +14,17 @@
         "empty error message";                                           \
       napi_throw_error((env), error_message);                            \
     }                                                                    \
-  } while(0);
+  } while (0)
 
 #define NAPI_ASSERT_BASE(env, assertion, message, ret_val)               \
-  if (!(assertion)) {                                                    \
-    napi_throw_error(                                                    \
-        (env),                                                           \
-        "assertion (" #assertion ") failed: " message);                  \
-    return ret_val;                                                      \
-  }
+  do {                                                                   \
+    if (!(assertion)) {                                                  \
+      napi_throw_error(                                                  \
+          (env),                                                         \
+          "assertion (" #assertion ") failed: " message);                \
+      return ret_val;                                                    \
+    }                                                                    \
+  } while (0)
 
 // Returns NULL on failed assertion.
 // This is meant to be used inside napi_callback methods.
@@ -35,10 +37,12 @@
   NAPI_ASSERT_BASE(env, assertion, message, NAPI_RETVAL_NOTHING)
 
 #define NAPI_CALL_BASE(env, the_call, ret_val)                           \
-  if ((the_call) != napi_ok) {                                           \
-    GET_AND_THROW_LAST_ERROR((env));                                     \
-    return ret_val;                                                      \
-  }
+  do {                                                                   \
+    if ((the_call) != napi_ok) {                                         \
+      GET_AND_THROW_LAST_ERROR((env));                                   \
+      return ret_val;                                                    \
+    }                                                                    \
+  } while (0)
 
 // Returns NULL if the_call doesn't return napi_ok.
 #define NAPI_CALL(env, the_call)                                         \
diff --git a/test/addons-napi/test_object/test_object.c b/test/addons-napi/test_object/test_object.c
index 96a7aa9c205ccf..663e561a35b197 100644
--- a/test/addons-napi/test_object/test_object.c
+++ b/test/addons-napi/test_object/test_object.c
@@ -53,7 +53,7 @@ napi_value Set(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_set_property(env, args[0], args[1], args[2]));
 
   napi_value valuetrue;
-  NAPI_CALL(env, napi_get_boolean(env, true, &valuetrue))
+  NAPI_CALL(env, napi_get_boolean(env, true, &valuetrue));
 
   return valuetrue;
 }
diff --git a/test/addons-napi/test_reference/test_reference.c b/test/addons-napi/test_reference/test_reference.c
index 9be9fd135fb0e9..0d3925ee5d04bc 100644
--- a/test/addons-napi/test_reference/test_reference.c
+++ b/test/addons-napi/test_reference/test_reference.c
@@ -58,13 +58,13 @@ napi_value CheckExternal(napi_env env, napi_callback_info info) {
   napi_valuetype argtype;
   NAPI_CALL(env, napi_typeof(env, arg, &argtype));
 
-  NAPI_ASSERT(env, argtype == napi_external, "Expected an external value.")
+  NAPI_ASSERT(env, argtype == napi_external, "Expected an external value.");
 
   void* data;
   NAPI_CALL(env, napi_get_value_external(env, arg, &data));
 
   NAPI_ASSERT(env, data != NULL && *(int*)data == test_value,
-    "An external data value of 1 was expected.")
+    "An external data value of 1 was expected.");
 
   return NULL;
 }

From fb572c4fc7f0540f906a5d3c088afcc3947fb753 Mon Sep 17 00:00:00 2001
From: cjihrig <cjihrig@gmail.com>
Date: Fri, 7 Jul 2017 09:33:23 -0400
Subject: [PATCH 078/183] test: handle missing V8 tests in n-api test
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The N-API test testInstanceOf.js relies on several V8 test files
which may not exist in downloadable archives. If the files are
missing, this commit causes a warning to be emitted rather than
failing the test.

Refs: https://github.com/nodejs/node/issues/14113
Fixes: https://github.com/nodejs/node/issues/13344
PR-URL: https://github.com/nodejs/node/pull/14123
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 .../test_general/testInstanceOf.js            | 32 ++++++++++++-------
 1 file changed, 20 insertions(+), 12 deletions(-)

diff --git a/test/addons-napi/test_general/testInstanceOf.js b/test/addons-napi/test_general/testInstanceOf.js
index 3279979719dc37..862155a967548f 100644
--- a/test/addons-napi/test_general/testInstanceOf.js
+++ b/test/addons-napi/test_general/testInstanceOf.js
@@ -9,6 +9,11 @@ const assert = require('assert');
 const addon = require(`./build/${common.buildType}/test_general`);
 const path = require('path');
 
+// This test depends on a number of V8 tests.
+const v8TestsDir = path.resolve(__dirname, '..', '..', '..', 'deps', 'v8',
+                                'test', 'mjsunit');
+const v8TestsDirExists = fs.existsSync(v8TestsDir);
+
 // The following assert functions are referenced by v8's unit tests
 // See for instance deps/v8/test/mjsunit/instanceof.js
 // eslint-disable-next-line no-unused-vars
@@ -34,19 +39,22 @@ function assertThrows(statement) {
 }
 
 function testFile(fileName) {
-  const contents = fs.readFileSync(fileName, { encoding: 'utf8' });
-  eval(contents.replace(/[(]([^\s(]+)\s+instanceof\s+([^)]+)[)]/g,
-                        '(addon.doInstanceOf($1, $2))'));
+  try {
+    const contents = fs.readFileSync(fileName, { encoding: 'utf8' });
+    eval(contents.replace(/[(]([^\s(]+)\s+instanceof\s+([^)]+)[)]/g,
+                          '(addon.doInstanceOf($1, $2))'));
+  } catch (err) {
+    // This test depends on V8 test files, which may not exist in downloaded
+    // archives. Emit a warning if the tests cannot be found instead of failing.
+    if (err.code === 'ENOENT' && !v8TestsDirExists)
+      process.emitWarning(`test file ${fileName} does not exist.`);
+    else
+      throw err;
+  }
 }
 
-testFile(
-    path.join(path.resolve(__dirname, '..', '..', '..',
-                           'deps', 'v8', 'test', 'mjsunit'),
-              'instanceof.js'));
-testFile(
-    path.join(path.resolve(__dirname, '..', '..', '..',
-                           'deps', 'v8', 'test', 'mjsunit'),
-              'instanceof-2.js'));
+testFile(path.join(v8TestsDir, 'instanceof.js'));
+testFile(path.join(v8TestsDir, 'instanceof-2.js'));
 
 // We can only perform this test if we have a working Symbol.hasInstance
 if (typeof Symbol !== 'undefined' && 'hasInstance' in Symbol &&
@@ -54,7 +62,7 @@ if (typeof Symbol !== 'undefined' && 'hasInstance' in Symbol &&
 
   function compareToNative(theObject, theConstructor) {
     assert.strictEqual(addon.doInstanceOf(theObject, theConstructor),
-      (theObject instanceof theConstructor));
+                       (theObject instanceof theConstructor));
   }
 
   function MyClass() {}

From 52782239eb870986d88d0d234af7e13ed2a03b43 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Wed, 28 Jun 2017 21:53:18 -0400
Subject: [PATCH 079/183] n-api: add code parameter to error helpers

In support of the effort to add error codes to all errors
generated by Node.js, add an optional code parameter to the
helper functions used to throw/create errors in N-API.

PR-URL: https://github.com/nodejs/node/pull/13988
Fixes: https://github.com/nodejs/node/issues/13933
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 doc/api/n-api.md                              |  49 ++++++-
 src/node_api.cc                               | 120 ++++++++++++++++--
 src/node_api.h                                |  15 ++-
 test/addons-napi/common.h                     |   3 +-
 test/addons-napi/test_async/test_async.cc     |   6 +-
 test/addons-napi/test_error/test.js           |  62 +++++++++
 test/addons-napi/test_error/test_error.cc     |  76 ++++++++++-
 .../test_typedarray/test_typedarray.c         |   2 +-
 test/common/index.js                          |  53 ++++++++
 9 files changed, 354 insertions(+), 32 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 8063eaf7348dc0..875ced3579ecf0 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -323,6 +323,31 @@ code needs to create an Error object: [`napi_create_error`][],
 where result is the napi_value that refers to the newly created
 JavaScript Error object.
 
+The Node.js project is adding error codes to all of the errors
+generated internally.  The goal is for applications to use these
+error codes for all error checking. The associated error messages
+will remain, but will only be meant to be used for logging and
+display with the expectation that the message can change without
+SemVer applying. In order to support this model with N-API, both
+in internal functionality and for module specific functionality
+(as its good practice), the `throw_` and `create_` functions
+take an optional code parameter which is the string for the code
+to be added to the error object.  If the optional parameter is NULL
+then no code will be associated with the error. If a code is provided,
+the name associated with the error is also updated to be:
+
+```
+originalName [code]
+```
+
+where originalName is the original name associated with the error
+and code is the code that was provided.  For example if the code
+is 'ERR_ERROR_1' and a TypeError is being created the name will be:
+
+```
+TypeError [ERR_ERROR_1]
+```
+
 #### napi_throw
 <!-- YAML
 added: v8.0.0
@@ -343,9 +368,12 @@ This API throws the JavaScript Error provided.
 added: v8.0.0
 -->
 ```C
-NODE_EXTERN napi_status napi_throw_error(napi_env env, const char* msg);
+NODE_EXTERN napi_status napi_throw_error(napi_env env,
+                                         const char* code,
+                                         const char* msg);
 ```
 - `[in] env`: The environment that the API is invoked under.
+- `[in] code`: Optional error code to be set on the error.
 - `[in] msg`: C string representing the text to be associated with
 the error.
 
@@ -358,9 +386,12 @@ This API throws a JavaScript Error with the text provided.
 added: v8.0.0
 -->
 ```C
-NODE_EXTERN napi_status napi_throw_type_error(napi_env env, const char* msg);
+NODE_EXTERN napi_status napi_throw_type_error(napi_env env,
+                                              const char* code,
+                                              const char* msg);
 ```
 - `[in] env`: The environment that the API is invoked under.
+- `[in] code`: Optional error code to be set on the error.
 - `[in] msg`: C string representing the text to be associated with
 the error.
 
@@ -373,9 +404,12 @@ This API throws a JavaScript TypeError with the text provided.
 added: v8.0.0
 -->
 ```C
-NODE_EXTERN napi_status napi_throw_range_error(napi_env env, const char* msg);
+NODE_EXTERN napi_status napi_throw_range_error(napi_env env,
+                                               const char* code,
+                                               const char* msg);
 ```
 - `[in] env`: The environment that the API is invoked under.
+- `[in] code`: Optional error code to be set on the error.
 - `[in] msg`: C string representing the text to be associated with
 the error.
 
@@ -409,10 +443,13 @@ added: v8.0.0
 -->
 ```C
 NODE_EXTERN napi_status napi_create_error(napi_env env,
+                                          napi_value code,
                                           napi_value msg,
                                           napi_value* result);
 ```
 - `[in] env`: The environment that the API is invoked under.
+- `[in] code`: Optional `napi_value` with the string for the error code to
+               be associated with the error.
 - `[in] msg`: napi_value that references a JavaScript String to be
 used as the message for the Error.
 - `[out] result`: `napi_value` representing the error created.
@@ -427,10 +464,13 @@ added: v8.0.0
 -->
 ```C
 NODE_EXTERN napi_status napi_create_type_error(napi_env env,
+                                               napi_value code,
                                                napi_value msg,
                                                napi_value* result);
 ```
 - `[in] env`: The environment that the API is invoked under.
+- `[in] code`: Optional `napi_value` with the string for the error code to
+               be associated with the error.
 - `[in] msg`: napi_value that references a JavaScript String to be
 used as the message for the Error.
 - `[out] result`: `napi_value` representing the error created.
@@ -446,10 +486,13 @@ added: v8.0.0
 -->
 ```C
 NODE_EXTERN napi_status napi_create_range_error(napi_env env,
+                                                napi_value code,
                                                 const char* msg,
                                                 napi_value* result);
 ```
 - `[in] env`: The environment that the API is invoked under.
+- `[in] code`: Optional `napi_value` with the string for the error code to
+               be associated with the error.
 - `[in] msg`: napi_value that references a JavaScript String to be
 used as the message for the Error.
 - `[out] result`: `napi_value` representing the error created.
diff --git a/src/node_api.cc b/src/node_api.cc
index fee00dabe9a14d..25e8c6385572e7 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -21,6 +21,7 @@
 #include "node_internals.h"
 #include "env-inl.h"
 #include "node_api_backport.h"
+#include "util.h"
 
 #define NAPI_VERSION  1
 
@@ -1525,7 +1526,61 @@ napi_status napi_create_symbol(napi_env env,
   return GET_RETURN_STATUS(env);
 }
 
+static napi_status set_error_code(napi_env env,
+                                  v8::Local<v8::Value> error,
+                                  napi_value code,
+                                  const char* code_cstring) {
+  if ((code != nullptr) || (code_cstring != nullptr)) {
+    v8::Isolate* isolate = env->isolate;
+    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    v8::Local<v8::Object> err_object = error.As<v8::Object>();
+
+    v8::Local<v8::Value> code_value = v8impl::V8LocalValueFromJsValue(code);
+    if (code != nullptr) {
+      code_value = v8impl::V8LocalValueFromJsValue(code);
+      RETURN_STATUS_IF_FALSE(env, code_value->IsString(), napi_string_expected);
+    } else {
+      CHECK_NEW_FROM_UTF8(env, code_value, code_cstring);
+    }
+
+    v8::Local<v8::Name> code_key;
+    CHECK_NEW_FROM_UTF8(env, code_key, "code");
+
+    v8::Maybe<bool> set_maybe = err_object->Set(context, code_key, code_value);
+    RETURN_STATUS_IF_FALSE(env,
+                           set_maybe.FromMaybe(false),
+                           napi_generic_failure);
+
+    // now update the name to be "name [code]" where name is the
+    // original name and code is the code associated with the Error
+    v8::Local<v8::String> name_string;
+    CHECK_NEW_FROM_UTF8(env, name_string, "");
+    v8::Local<v8::Name> name_key;
+    CHECK_NEW_FROM_UTF8(env, name_key, "name");
+
+    auto maybe_name = err_object->Get(context, name_key);
+    if (!maybe_name.IsEmpty()) {
+      v8::Local<v8::Value> name = maybe_name.ToLocalChecked();
+      if (name->IsString()) {
+        name_string = v8::String::Concat(name_string, name.As<v8::String>());
+      }
+    }
+    name_string = v8::String::Concat(name_string,
+                                     FIXED_ONE_BYTE_STRING(isolate, " ["));
+    name_string = v8::String::Concat(name_string, code_value.As<v8::String>());
+    name_string = v8::String::Concat(name_string,
+                                     FIXED_ONE_BYTE_STRING(isolate, "]"));
+
+    set_maybe = err_object->Set(context, name_key, name_string);
+    RETURN_STATUS_IF_FALSE(env,
+                           set_maybe.FromMaybe(false),
+                           napi_generic_failure);
+  }
+  return napi_ok;
+}
+
 napi_status napi_create_error(napi_env env,
+                              napi_value code,
                               napi_value msg,
                               napi_value* result) {
   NAPI_PREAMBLE(env);
@@ -1535,13 +1590,18 @@ napi_status napi_create_error(napi_env env,
   v8::Local<v8::Value> message_value = v8impl::V8LocalValueFromJsValue(msg);
   RETURN_STATUS_IF_FALSE(env, message_value->IsString(), napi_string_expected);
 
-  *result = v8impl::JsValueFromV8LocalValue(v8::Exception::Error(
-      message_value.As<v8::String>()));
+  v8::Local<v8::Value> error_obj =
+      v8::Exception::Error(message_value.As<v8::String>());
+  napi_status status = set_error_code(env, error_obj, code, nullptr);
+  if (status != napi_ok) return status;
+
+  *result = v8impl::JsValueFromV8LocalValue(error_obj);
 
   return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_create_type_error(napi_env env,
+                                   napi_value code,
                                    napi_value msg,
                                    napi_value* result) {
   NAPI_PREAMBLE(env);
@@ -1551,13 +1611,18 @@ napi_status napi_create_type_error(napi_env env,
   v8::Local<v8::Value> message_value = v8impl::V8LocalValueFromJsValue(msg);
   RETURN_STATUS_IF_FALSE(env, message_value->IsString(), napi_string_expected);
 
-  *result = v8impl::JsValueFromV8LocalValue(v8::Exception::TypeError(
-      message_value.As<v8::String>()));
+  v8::Local<v8::Value> error_obj =
+      v8::Exception::TypeError(message_value.As<v8::String>());
+  napi_status status = set_error_code(env, error_obj, code, nullptr);
+  if (status != napi_ok) return status;
+
+  *result = v8impl::JsValueFromV8LocalValue(error_obj);
 
   return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_create_range_error(napi_env env,
+                                    napi_value code,
                                     napi_value msg,
                                     napi_value* result) {
   NAPI_PREAMBLE(env);
@@ -1567,8 +1632,12 @@ napi_status napi_create_range_error(napi_env env,
   v8::Local<v8::Value> message_value = v8impl::V8LocalValueFromJsValue(msg);
   RETURN_STATUS_IF_FALSE(env, message_value->IsString(), napi_string_expected);
 
-  *result = v8impl::JsValueFromV8LocalValue(v8::Exception::RangeError(
-      message_value.As<v8::String>()));
+  v8::Local<v8::Value> error_obj =
+      v8::Exception::RangeError(message_value.As<v8::String>());
+  napi_status status = set_error_code(env, error_obj, code, nullptr);
+  if (status != napi_ok) return status;
+
+  *result = v8impl::JsValueFromV8LocalValue(error_obj);
 
   return GET_RETURN_STATUS(env);
 }
@@ -1741,40 +1810,58 @@ napi_status napi_throw(napi_env env, napi_value error) {
   return napi_clear_last_error(env);
 }
 
-napi_status napi_throw_error(napi_env env, const char* msg) {
+napi_status napi_throw_error(napi_env env,
+                             const char* code,
+                             const char* msg) {
   NAPI_PREAMBLE(env);
 
   v8::Isolate* isolate = env->isolate;
   v8::Local<v8::String> str;
   CHECK_NEW_FROM_UTF8(env, str, msg);
 
-  isolate->ThrowException(v8::Exception::Error(str));
+  v8::Local<v8::Value> error_obj = v8::Exception::Error(str);
+  napi_status status = set_error_code(env, error_obj, nullptr, code);
+  if (status != napi_ok) return status;
+
+  isolate->ThrowException(error_obj);
   // any VM calls after this point and before returning
   // to the javascript invoker will fail
   return napi_clear_last_error(env);
 }
 
-napi_status napi_throw_type_error(napi_env env, const char* msg) {
+napi_status napi_throw_type_error(napi_env env,
+                                  const char* code,
+                                  const char* msg) {
   NAPI_PREAMBLE(env);
 
   v8::Isolate* isolate = env->isolate;
   v8::Local<v8::String> str;
   CHECK_NEW_FROM_UTF8(env, str, msg);
 
-  isolate->ThrowException(v8::Exception::TypeError(str));
+  v8::Local<v8::Value> error_obj = v8::Exception::TypeError(str);
+  napi_status status = set_error_code(env, error_obj, nullptr, code);
+  if (status != napi_ok) return status;
+
+  isolate->ThrowException(error_obj);
   // any VM calls after this point and before returning
   // to the javascript invoker will fail
   return napi_clear_last_error(env);
 }
 
-napi_status napi_throw_range_error(napi_env env, const char* msg) {
+napi_status napi_throw_range_error(napi_env env,
+                                   const char* code,
+                                   const char* msg) {
   NAPI_PREAMBLE(env);
 
   v8::Isolate* isolate = env->isolate;
   v8::Local<v8::String> str;
   CHECK_NEW_FROM_UTF8(env, str, msg);
 
-  isolate->ThrowException(v8::Exception::RangeError(str));
+  v8::Local<v8::Value> error_obj = v8::Exception::RangeError(str);
+  napi_status status = set_error_code(env, error_obj, nullptr, code);
+  if (status != napi_ok) return status;
+
+  isolate->ThrowException(error_obj);
   // any VM calls after this point and before returning
   // to the javascript invoker will fail
   return napi_clear_last_error(env);
@@ -2394,7 +2481,9 @@ napi_status napi_instanceof(napi_env env,
   CHECK_TO_OBJECT(env, context, ctor, constructor);
 
   if (!ctor->IsFunction()) {
-    napi_throw_type_error(env, "constructor must be a function");
+    napi_throw_type_error(env,
+                          "ERR_NAPI_CONS_FUNCTION",
+                          "Constructor must be a function");
 
     return napi_set_last_error(env, napi_function_expected);
   }
@@ -2462,7 +2551,10 @@ napi_status napi_instanceof(napi_env env,
 
   v8::Local<v8::Value> prototype_property = maybe_prototype.ToLocalChecked();
   if (!prototype_property->IsObject()) {
-    napi_throw_type_error(env, "constructor.prototype must be an object");
+    napi_throw_type_error(
+        env,
+        "ERR_NAPI_CONS_PROTOTYPE_OBJECT",
+        "Constructor.prototype must be an object");
 
     return napi_set_last_error(env, napi_object_expected);
   }
diff --git a/src/node_api.h b/src/node_api.h
index e346b762dd2702..af98789d418210 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -142,12 +142,15 @@ NAPI_EXTERN napi_status napi_create_function(napi_env env,
                                              void* data,
                                              napi_value* result);
 NAPI_EXTERN napi_status napi_create_error(napi_env env,
+                                          napi_value code,
                                           napi_value msg,
                                           napi_value* result);
 NAPI_EXTERN napi_status napi_create_type_error(napi_env env,
+                                               napi_value code,
                                                napi_value msg,
                                                napi_value* result);
 NAPI_EXTERN napi_status napi_create_range_error(napi_env env,
+                                                napi_value code,
                                                 napi_value msg,
                                                 napi_value* result);
 
@@ -404,9 +407,15 @@ NAPI_EXTERN napi_status napi_escape_handle(napi_env env,
 
 // Methods to support error handling
 NAPI_EXTERN napi_status napi_throw(napi_env env, napi_value error);
-NAPI_EXTERN napi_status napi_throw_error(napi_env env, const char* msg);
-NAPI_EXTERN napi_status napi_throw_type_error(napi_env env, const char* msg);
-NAPI_EXTERN napi_status napi_throw_range_error(napi_env env, const char* msg);
+NAPI_EXTERN napi_status napi_throw_error(napi_env env,
+                                         const char* code,
+                                         const char* msg);
+NAPI_EXTERN napi_status napi_throw_type_error(napi_env env,
+                                         const char* code,
+                                         const char* msg);
+NAPI_EXTERN napi_status napi_throw_range_error(napi_env env,
+                                         const char* code,
+                                         const char* msg);
 NAPI_EXTERN napi_status napi_is_error(napi_env env,
                                       napi_value value,
                                       bool* result);
diff --git a/test/addons-napi/common.h b/test/addons-napi/common.h
index e9640935d4154b..422418ced49a39 100644
--- a/test/addons-napi/common.h
+++ b/test/addons-napi/common.h
@@ -12,7 +12,7 @@
       const char* error_message = error_info->error_message != NULL ?    \
         error_info->error_message :                                      \
         "empty error message";                                           \
-      napi_throw_error((env), error_message);                            \
+      napi_throw_error((env), NULL, error_message);                      \
     }                                                                    \
   } while (0)
 
@@ -21,6 +21,7 @@
     if (!(assertion)) {                                                  \
       napi_throw_error(                                                  \
           (env),                                                         \
+        NULL,                                                            \
           "assertion (" #assertion ") failed: " message);                \
       return ret_val;                                                    \
     }                                                                    \
diff --git a/test/addons-napi/test_async/test_async.cc b/test/addons-napi/test_async/test_async.cc
index cc7bc334304323..f257b268b93159 100644
--- a/test/addons-napi/test_async/test_async.cc
+++ b/test/addons-napi/test_async/test_async.cc
@@ -29,7 +29,7 @@ void Execute(napi_env env, void* data) {
   carrier* c = static_cast<carrier*>(data);
 
   if (c != &the_carrier) {
-    napi_throw_type_error(env, "Wrong data parameter to Execute.");
+    napi_throw_type_error(env, nullptr, "Wrong data parameter to Execute.");
     return;
   }
 
@@ -40,12 +40,12 @@ void Complete(napi_env env, napi_status status, void* data) {
   carrier* c = static_cast<carrier*>(data);
 
   if (c != &the_carrier) {
-    napi_throw_type_error(env, "Wrong data parameter to Complete.");
+    napi_throw_type_error(env, nullptr, "Wrong data parameter to Complete.");
     return;
   }
 
   if (status != napi_ok) {
-    napi_throw_type_error(env, "Execute callback failed.");
+    napi_throw_type_error(env, nullptr, "Execute callback failed.");
     return;
   }
 
diff --git a/test/addons-napi/test_error/test.js b/test/addons-napi/test_error/test.js
index f7479f2c9a64d8..80f99f48ba79f3 100644
--- a/test/addons-napi/test_error/test.js
+++ b/test/addons-napi/test_error/test.js
@@ -72,6 +72,30 @@ assert.throws(() => {
   test_error.throwTypeError();
 }, /^TypeError: type error$/);
 
+assert.throws(
+  () => test_error.throwErrorCode(),
+  common.expectsError({
+    code: 'ERR_TEST_CODE',
+    message: 'Error [error]'
+  })
+);
+
+assert.throws(
+  () => test_error.throwRangeErrorCode(),
+  common.expectsError({
+    code: 'ERR_TEST_CODE',
+    message: 'RangeError [range error]'
+  })
+);
+
+assert.throws(
+  () => test_error.throwTypeErrorCode(),
+  common.expectsError({
+    code: 'ERR_TEST_CODE',
+    message: 'TypeError [type error]'
+  })
+);
+
 let error = test_error.createError();
 assert.ok(error instanceof Error, 'expected error to be an instance of Error');
 assert.strictEqual(error.message, 'error', 'expected message to be "error"');
@@ -89,3 +113,41 @@ assert.ok(error instanceof TypeError,
 assert.strictEqual(error.message,
                    'type error',
                    'expected message to be "type error"');
+
+error = test_error.createErrorCode();
+assert.ok(error instanceof Error, 'expected error to be an instance of Error');
+assert.strictEqual(error.code,
+                   'ERR_TEST_CODE',
+                   'expected code to be "ERR_TEST_CODE"');
+assert.strictEqual(error.message,
+                   'Error [error]',
+                   'expected message to be "Error [error]"');
+assert.strictEqual(error.name,
+                   'Error [ERR_TEST_CODE]',
+                   'expected name to be "Error [ERR_TEST_CODE]"');
+
+error = test_error.createRangeErrorCode();
+assert.ok(error instanceof RangeError,
+          'expected error to be an instance of RangeError');
+assert.strictEqual(error.message,
+                   'RangeError [range error]',
+                   'expected message to be "RangeError [range error]"');
+assert.strictEqual(error.code,
+                   'ERR_TEST_CODE',
+                   'expected code to be "ERR_TEST_CODE"');
+assert.strictEqual(error.name,
+                   'RangeError [ERR_TEST_CODE]',
+                   'expected name to be "RangeError[ERR_TEST_CODE]"');
+
+error = test_error.createTypeErrorCode();
+assert.ok(error instanceof TypeError,
+          'expected error to be an instance of TypeError');
+assert.strictEqual(error.message,
+                   'TypeError [type error]',
+                   'expected message to be "TypeError [type error]"');
+assert.strictEqual(error.code,
+                   'ERR_TEST_CODE',
+                   'expected code to be "ERR_TEST_CODE"');
+assert.strictEqual(error.name,
+                   'TypeError [ERR_TEST_CODE]',
+                   'expected name to be "TypeError[ERR_TEST_CODE]"');
diff --git a/test/addons-napi/test_error/test_error.cc b/test/addons-napi/test_error/test_error.cc
index ddba2059f23be6..29aba1f1ef62f6 100644
--- a/test/addons-napi/test_error/test_error.cc
+++ b/test/addons-napi/test_error/test_error.cc
@@ -19,31 +19,51 @@ napi_value throwExistingError(napi_env env, napi_callback_info info) {
   napi_value message;
   napi_value error;
   NAPI_CALL(env, napi_create_string_utf8(env, "existing error", -1, &message));
-  NAPI_CALL(env, napi_create_error(env, message, &error));
+  NAPI_CALL(env, napi_create_error(env, nullptr,  message, &error));
   NAPI_CALL(env, napi_throw(env, error));
   return nullptr;
 }
 
 napi_value throwError(napi_env env, napi_callback_info info) {
-  NAPI_CALL(env, napi_throw_error(env, "error"));
+  NAPI_CALL(env, napi_throw_error(env, nullptr, "error"));
   return nullptr;
 }
 
 napi_value throwRangeError(napi_env env, napi_callback_info info) {
-  NAPI_CALL(env, napi_throw_range_error(env, "range error"));
+  NAPI_CALL(env, napi_throw_range_error(env, nullptr, "range error"));
   return nullptr;
 }
 
 napi_value throwTypeError(napi_env env, napi_callback_info info) {
-  NAPI_CALL(env, napi_throw_type_error(env, "type error"));
+  NAPI_CALL(env, napi_throw_type_error(env, nullptr, "type error"));
   return nullptr;
 }
 
+napi_value throwErrorCode(napi_env env, napi_callback_info info) {
+  NAPI_CALL(env, napi_throw_error(env, "ERR_TEST_CODE", "Error [error]"));
+  return nullptr;
+}
+
+napi_value throwRangeErrorCode(napi_env env, napi_callback_info info) {
+  NAPI_CALL(env, napi_throw_range_error(env,
+                                        "ERR_TEST_CODE",
+                                        "RangeError [range error]"));
+  return nullptr;
+}
+
+napi_value throwTypeErrorCode(napi_env env, napi_callback_info info) {
+  NAPI_CALL(env, napi_throw_type_error(env,
+                                       "ERR_TEST_CODE",
+                                       "TypeError [type error]"));
+  return nullptr;
+}
+
+
 napi_value createError(napi_env env, napi_callback_info info) {
   napi_value result;
   napi_value message;
   NAPI_CALL(env, napi_create_string_utf8(env, "error", -1, &message));
-  NAPI_CALL(env, napi_create_error(env, message, &result));
+  NAPI_CALL(env, napi_create_error(env, nullptr, message, &result));
   return result;
 }
 
@@ -51,7 +71,7 @@ napi_value createRangeError(napi_env env, napi_callback_info info) {
   napi_value result;
   napi_value message;
   NAPI_CALL(env, napi_create_string_utf8(env, "range error", -1, &message));
-  NAPI_CALL(env, napi_create_range_error(env, message, &result));
+  NAPI_CALL(env, napi_create_range_error(env, nullptr, message, &result));
   return result;
 }
 
@@ -59,7 +79,43 @@ napi_value createTypeError(napi_env env, napi_callback_info info) {
   napi_value result;
   napi_value message;
   NAPI_CALL(env, napi_create_string_utf8(env, "type error", -1, &message));
-  NAPI_CALL(env, napi_create_type_error(env, message, &result));
+  NAPI_CALL(env, napi_create_type_error(env, nullptr, message, &result));
+  return result;
+}
+
+napi_value createErrorCode(napi_env env, napi_callback_info info) {
+  napi_value result;
+  napi_value message;
+  napi_value code;
+  NAPI_CALL(env, napi_create_string_utf8(env, "Error [error]", -1, &message));
+  NAPI_CALL(env, napi_create_string_utf8(env, "ERR_TEST_CODE", -1, &code));
+  NAPI_CALL(env, napi_create_error(env, code, message, &result));
+  return result;
+}
+
+napi_value createRangeErrorCode(napi_env env, napi_callback_info info) {
+  napi_value result;
+  napi_value message;
+  napi_value code;
+  NAPI_CALL(env, napi_create_string_utf8(env,
+                                         "RangeError [range error]",
+                                         -1,
+                                         &message));
+  NAPI_CALL(env, napi_create_string_utf8(env, "ERR_TEST_CODE", -1, &code));
+  NAPI_CALL(env, napi_create_range_error(env, code, message, &result));
+  return result;
+}
+
+napi_value createTypeErrorCode(napi_env env, napi_callback_info info) {
+  napi_value result;
+  napi_value message;
+  napi_value code;
+  NAPI_CALL(env, napi_create_string_utf8(env,
+                                         "TypeError [type error]",
+                                         -1,
+                                         &message));
+  NAPI_CALL(env, napi_create_string_utf8(env, "ERR_TEST_CODE", -1, &code));
+  NAPI_CALL(env, napi_create_type_error(env, code, message, &result));
   return result;
 }
 
@@ -70,9 +126,15 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("throwError", throwError),
     DECLARE_NAPI_PROPERTY("throwRangeError", throwRangeError),
     DECLARE_NAPI_PROPERTY("throwTypeError", throwTypeError),
+    DECLARE_NAPI_PROPERTY("throwErrorCode", throwErrorCode),
+    DECLARE_NAPI_PROPERTY("throwRangeErrorCode", throwRangeErrorCode),
+    DECLARE_NAPI_PROPERTY("throwTypeErrorCode", throwTypeErrorCode),
     DECLARE_NAPI_PROPERTY("createError", createError),
     DECLARE_NAPI_PROPERTY("createRangeError", createRangeError),
     DECLARE_NAPI_PROPERTY("createTypeError", createTypeError),
+    DECLARE_NAPI_PROPERTY("createErrorCode", createErrorCode),
+    DECLARE_NAPI_PROPERTY("createRangeErrorCode", createRangeErrorCode),
+    DECLARE_NAPI_PROPERTY("createTypeErrorCode", createTypeErrorCode),
   };
 
   NAPI_CALL_RETURN_VOID(env, napi_define_properties(
diff --git a/test/addons-napi/test_typedarray/test_typedarray.c b/test/addons-napi/test_typedarray/test_typedarray.c
index 4194492cae8b3a..ffc118681bad9e 100644
--- a/test/addons-napi/test_typedarray/test_typedarray.c
+++ b/test/addons-napi/test_typedarray/test_typedarray.c
@@ -65,7 +65,7 @@ napi_value Multiply(napi_env env, napi_callback_info info) {
       output_doubles[i] = input_doubles[i] * multiplier;
     }
   } else {
-    napi_throw_error(env, "Typed array was of a type not expected by test.");
+    napi_throw_error(env, NULL, "Typed array was of a type not expected by test.");
     return NULL;
   }
 
diff --git a/test/common/index.js b/test/common/index.js
index d762f4e0aa8498..a5328e29ec998f 100644
--- a/test/common/index.js
+++ b/test/common/index.js
@@ -625,6 +625,59 @@ Object.defineProperty(exports, 'hasIntl', {
   }
 });
 
+// Useful for testing expected internal/error objects
+exports.expectsError = function expectsError(fn, settings, exact) {
+  if (typeof fn !== 'function') {
+    exact = settings;
+    settings = fn;
+    fn = undefined;
+  }
+  function innerFn(error) {
+    assert.strictEqual(error.code, settings.code);
+    if ('type' in settings) {
+      const type = settings.type;
+      if (type !== Error && !Error.isPrototypeOf(type)) {
+        throw new TypeError('`settings.type` must inherit from `Error`');
+      }
+      assert(error instanceof type,
+             `${error.name} is not instance of ${type.name}`);
+      let typeName = error.constructor.name;
+      if (typeName === 'NodeError' && type.name !== 'NodeError') {
+        typeName = Object.getPrototypeOf(error.constructor).name;
+      }
+      assert.strictEqual(typeName, type.name);
+    }
+    if ('message' in settings) {
+      const message = settings.message;
+      if (typeof message === 'string') {
+        assert.strictEqual(error.message, message);
+      } else {
+        assert(message.test(error.message),
+               `${error.message} does not match ${message}`);
+      }
+    }
+    if ('name' in settings) {
+      assert.strictEqual(error.name, settings.name);
+    }
+    if (error.constructor.name === 'AssertionError') {
+      ['generatedMessage', 'actual', 'expected', 'operator'].forEach((key) => {
+        if (key in settings) {
+          const actual = error[key];
+          const expected = settings[key];
+          assert.strictEqual(actual, expected,
+                             `${key}: expected ${expected}, not ${actual}`);
+        }
+      });
+    }
+    return true;
+  }
+  if (fn) {
+    assert.throws(fn, innerFn);
+    return;
+  }
+  return exports.mustCall(innerFn, exact);
+};
+
 // Crash the process on unhandled rejections.
 exports.crashOnUnhandledRejection = function() {
   process.on('unhandledRejection',

From 25e46c52ac1a769a572c33882ead6eddb29da76f Mon Sep 17 00:00:00 2001
From: Kyle Farnung <kfarnung@microsoft.com>
Date: Tue, 27 Jun 2017 17:54:44 -0700
Subject: [PATCH 080/183] n-api: add napi_fatal_error API

PR-URL: https://github.com/nodejs/node/pull/13971
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 doc/api/n-api.md                         | 17 +++++++++++++++++
 src/node_api.cc                          |  5 +++++
 src/node_api.h                           |  9 +++++++++
 test/addons-napi/test_fatal/binding.gyp  |  8 ++++++++
 test/addons-napi/test_fatal/test.js      | 18 ++++++++++++++++++
 test/addons-napi/test_fatal/test_fatal.c | 18 ++++++++++++++++++
 6 files changed, 75 insertions(+)
 create mode 100644 test/addons-napi/test_fatal/binding.gyp
 create mode 100644 test/addons-napi/test_fatal/test.js
 create mode 100644 test/addons-napi/test_fatal/test_fatal.c

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 875ced3579ecf0..8aac594f8323cd 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -533,6 +533,23 @@ Returns `napi_ok` if the API succeeded.
 
 This API returns true if an exception is pending.
 
+### Fatal Errors
+
+In the event of an unrecoverable error in a native module, a fatal error can be
+thrown to immediately terminate the process.
+
+#### napi_fatal_error
+<!-- YAML
+added: REPLACEME
+-->
+```C
+NAPI_EXTERN NAPI_NO_RETURN void napi_fatal_error(const char* location, const char* message);
+```
+
+- `[in] location`: Optional location at which the error occurred.
+- `[in] message`: The message associated with the error.
+
+The function call does not return, the process will be terminated.
 
 ## Object Lifetime management
 
diff --git a/src/node_api.cc b/src/node_api.cc
index 25e8c6385572e7..58aeaf08979501 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -826,6 +826,11 @@ napi_status napi_get_last_error_info(napi_env env,
   return napi_ok;
 }
 
+NAPI_NO_RETURN void napi_fatal_error(const char* location,
+                                     const char* message) {
+  node::FatalError(location, message);
+}
+
 napi_status napi_create_function(napi_env env,
                                  const char* utf8name,
                                  napi_callback cb,
diff --git a/src/node_api.h b/src/node_api.h
index af98789d418210..f4d097ad104cf9 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -37,6 +37,12 @@
 # define NAPI_MODULE_EXPORT __attribute__((visibility("default")))
 #endif
 
+#ifdef __GNUC__
+#define NAPI_NO_RETURN __attribute__((noreturn))
+#else
+#define NAPI_NO_RETURN
+#endif
+
 
 typedef void (*napi_addon_register_func)(napi_env env,
                                          napi_value exports,
@@ -104,6 +110,9 @@ NAPI_EXTERN napi_status
 napi_get_last_error_info(napi_env env,
                          const napi_extended_error_info** result);
 
+NAPI_EXTERN NAPI_NO_RETURN void napi_fatal_error(const char* location,
+                                                 const char* message);
+
 // Getters for defined singletons
 NAPI_EXTERN napi_status napi_get_undefined(napi_env env, napi_value* result);
 NAPI_EXTERN napi_status napi_get_null(napi_env env, napi_value* result);
diff --git a/test/addons-napi/test_fatal/binding.gyp b/test/addons-napi/test_fatal/binding.gyp
new file mode 100644
index 00000000000000..ad661825f1fa9b
--- /dev/null
+++ b/test/addons-napi/test_fatal/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_fatal",
+      "sources": [ "test_fatal.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_fatal/test.js b/test/addons-napi/test_fatal/test.js
new file mode 100644
index 00000000000000..aa37dc6803f0d5
--- /dev/null
+++ b/test/addons-napi/test_fatal/test.js
@@ -0,0 +1,18 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const child_process = require('child_process');
+const test_fatal = require(`./build/${common.buildType}/test_fatal`);
+
+// Test in a child process because the test code will trigger a fatal error
+// that crashes the process.
+if (process.argv[2] === 'child') {
+  test_fatal.Test();
+  return;
+}
+
+const p = child_process.spawnSync(
+    process.execPath, [ '--napi-modules', __filename, 'child' ]);
+assert.ifError(p.error);
+assert.ok(p.stderr.toString().includes(
+    'FATAL ERROR: test_fatal::Test fatal message'));
diff --git a/test/addons-napi/test_fatal/test_fatal.c b/test/addons-napi/test_fatal/test_fatal.c
new file mode 100644
index 00000000000000..1e8a1cf7955d18
--- /dev/null
+++ b/test/addons-napi/test_fatal/test_fatal.c
@@ -0,0 +1,18 @@
+#include <node_api.h>
+#include "../common.h"
+
+napi_value Test(napi_env env, napi_callback_info info) {
+  napi_fatal_error("test_fatal::Test", "fatal message");
+  return NULL;
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_property_descriptor properties[] = {
+    DECLARE_NAPI_PROPERTY("Test", Test),
+  };
+
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+      env, exports, sizeof(properties) / sizeof(*properties), properties));
+}
+
+NAPI_MODULE(addon, Init)

From bc83e71e1651637f59d367cc11e7938bfa62cf72 Mon Sep 17 00:00:00 2001
From: "Song, Bintao Garfield" <songbintaochina@gmail.com>
Date: Sun, 16 Jul 2017 15:08:33 +0800
Subject: [PATCH 081/183] test: replace string concat with template literal

Replace the string concat at test/addons-napi/test_reference/test.js.

PR-URL: https://github.com/nodejs/node/pull/14269
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 test/addons-napi/test_reference/test.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/addons-napi/test_reference/test.js b/test/addons-napi/test_reference/test.js
index aaf5531f39e1f3..14932a74ca70b0 100644
--- a/test/addons-napi/test_reference/test.js
+++ b/test/addons-napi/test_reference/test.js
@@ -22,7 +22,7 @@ function runTests(i, title, tests) {
       try {
         tests[i]();
       } catch (e) {
-        console.error('Test failed: ' + title);
+        console.error(`Test failed: ${title}`);
         throw e;
       }
       setImmediate(() => {

From e88566170015c68a043bd3bf5bfa112d59097a26 Mon Sep 17 00:00:00 2001
From: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Date: Thu, 20 Jul 2017 21:01:51 +0300
Subject: [PATCH 082/183] doc: fix some links

PR-URL: https://github.com/nodejs/node/pull/14400
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Yuta Hiroto <hello@about-hiroppy.com>
Reviewed-By: Khaidi Chu <i@2333.moe>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 doc/api/dns.md              |  4 ++--
 doc/api/n-api.md            |  1 +
 doc/guides/writing-tests.md | 11 +++++------
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/doc/api/dns.md b/doc/api/dns.md
index 7fce91970aa10e..1052a46c200f3f 100644
--- a/doc/api/dns.md
+++ b/doc/api/dns.md
@@ -175,7 +175,7 @@ added: v0.1.27
 - `rrtype` {string} Resource record type. Default: `'A'`.
 - `callback` {Function}
   - `err` {Error}
-  - `records` {string[] | Object[] | string[][] | Object}
+  - `records` {string[] | Object[] | Object}
 
 Uses the DNS protocol to resolve a hostname (e.g. `'nodejs.org'`) into an array
 of the resource records. The `callback` function has arguments
@@ -362,7 +362,7 @@ added: v0.1.27
 - `hostname` {string}
 - `callback` {Function}
   - `err` {Error}
-  - `records` {string[][]}
+  - `records` {string[]}
 
 Uses the DNS protocol to resolve text queries (`TXT` records) for the
 `hostname`. The `records` argument passed to the `callback` function is a
diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 8aac594f8323cd..91780846ff2e4a 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -3204,6 +3204,7 @@ support it:
 [`napi_queue_async_work`]: #n_api_napi_queue_async_work
 [`napi_reference_ref`]: #n_api_napi_reference_ref
 [`napi_reference_unref`]: #n_api_napi_reference_unref
+[`napi_throw`]: #n_api_napi_throw
 [`napi_throw_error`]: #n_api_napi_throw_error
 [`napi_throw_range_error`]: #n_api_napi_throw_range_error
 [`napi_throw_type_error`]: #n_api_napi_throw_type_error
diff --git a/doc/guides/writing-tests.md b/doc/guides/writing-tests.md
index aac098640aec9e..cc87886656c06d 100644
--- a/doc/guides/writing-tests.md
+++ b/doc/guides/writing-tests.md
@@ -92,7 +92,7 @@ The test checks functionality in the `http` module.
 Most tests use the `assert` module to confirm expectations of the test.
 
 The require statements are sorted in
-[ASCII](http://man7.org/linux/man-pages/man7/ascii.7.html) order (digits, upper
+[ASCII][] order (digits, upper
 case, `_`, lower case).
 
 ### **Lines 10-21**
@@ -252,9 +252,9 @@ assert.throws(
 For performance considerations, we only use a selected subset of ES.Next
 features in JavaScript code in the `lib` directory. However, when writing
 tests, for the ease of backporting, it is encouraged to use those ES.Next
-features that can be used directly without a flag in [all maintained branches]
-(https://github.com/nodejs/lts). [node.green](http://node.green/) lists
-available features in each release.
+features that can be used directly without a flag in
+[all maintained branches][]. [node.green][] lists available features
+in each release.
 
 For example:
 
@@ -279,8 +279,7 @@ functions worked correctly with the `beforeExit` event, then it might be named
 ### Web Platform Tests
 
 Some of the tests for the WHATWG URL implementation (named
-`test-whatwg-url-*.js`) are imported from the
-[Web Platform Tests Project](https://github.com/w3c/web-platform-tests/tree/master/url).
+`test-whatwg-url-*.js`) are imported from the [Web Platform Tests Project][].
 These imported tests will be wrapped like this:
 
 ```js

From 55e3ca88bc1c40d582bf76eaba7059ba01386d41 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Thu, 20 Jul 2017 17:03:11 +0200
Subject: [PATCH 083/183] n-api: add fast paths for integer getters

Ref: https://github.com/nodejs/node/issues/14379
PR-URL: https://github.com/nodejs/node/pull/14393
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
---
 src/node_api.cc | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/src/node_api.cc b/src/node_api.cc
index 58aeaf08979501..986a9facccac9d 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -1912,6 +1912,12 @@ napi_status napi_get_value_int32(napi_env env,
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+
+  if (val->IsInt32()) {
+    *result = val.As<v8::Int32>()->Value();
+    return napi_clear_last_error(env);
+  }
+
   RETURN_STATUS_IF_FALSE(env, val->IsNumber(), napi_number_expected);
 
   v8::Isolate* isolate = env->isolate;
@@ -1931,6 +1937,12 @@ napi_status napi_get_value_uint32(napi_env env,
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+
+  if (val->IsUint32()) {
+    *result = val.As<v8::Uint32>()->Value();
+    return napi_clear_last_error(env);
+  }
+
   RETURN_STATUS_IF_FALSE(env, val->IsNumber(), napi_number_expected);
 
   v8::Isolate* isolate = env->isolate;
@@ -1950,6 +1962,13 @@ napi_status napi_get_value_int64(napi_env env,
   CHECK_ARG(env, result);
 
   v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+
+  // This is still a fast path very likely to be taken.
+  if (val->IsInt32()) {
+    *result = val.As<v8::Int32>()->Value();
+    return napi_clear_last_error(env);
+  }
+
   RETURN_STATUS_IF_FALSE(env, val->IsNumber(), napi_number_expected);
 
   // v8::Value::IntegerValue() converts NaN to INT64_MIN, inconsistent with

From 39ce757a48ec2cafb60c99b7fed6a03bd9ff0d37 Mon Sep 17 00:00:00 2001
From: Kyle Farnung <kfarnung@microsoft.com>
Date: Wed, 12 Jul 2017 17:14:00 -0700
Subject: [PATCH 084/183] n-api: directly create Local from Persistent

The `v8::PersistentBase<T>.Get` method didn't exist in node 4 and it's
just a helper which creates a new `v8::Local` from the given object.

PR-URL: https://github.com/nodejs/node/pull/14211
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
---
 src/node_api.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 986a9facccac9d..06f18562e7d3c0 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -58,7 +58,8 @@ struct napi_env__ {
       (destination)->SetInternalFieldCount((field_count));         \
       (env)->prefix ## _template.Reset(isolate, (destination));    \
     } else {                                                       \
-      (destination) = env->prefix ## _template.Get(isolate);       \
+      (destination) = v8::Local<v8::ObjectTemplate>::New(          \
+          isolate, env->prefix ## _template);                      \
     }                                                              \
   } while (0)
 

From 8fab9bc7482af0a7381c243186844e44febbd860 Mon Sep 17 00:00:00 2001
From: Pratik Jain <pratik.jain0509@gmail.com>
Date: Mon, 24 Jul 2017 11:37:31 +0000
Subject: [PATCH 085/183] test: changed error message validator

Replaced TypeError with RegEx to match the exact error message in file
test/addons-napi/test_properties/test.js. The RegEx will check the
validity of the error being thrown.

PR-URL: https://github.com/nodejs/node/pull/14443
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Yuta Hiroto <hello@about-hiroppy.com>
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 test/addons-napi/test_properties/test.js | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/test/addons-napi/test_properties/test.js b/test/addons-napi/test_properties/test.js
index 8d11a669d46daf..0a3bbee853610f 100644
--- a/test/addons-napi/test_properties/test.js
+++ b/test/addons-napi/test_properties/test.js
@@ -1,6 +1,7 @@
 'use strict';
 const common = require('../../common');
 const assert = require('assert');
+const readonlyErrorRE = /^TypeError: Cannot assign to read only property '.*' of object '#<Object>'$/;
 
 // Testing api calls for defining properties
 const test_object = require(`./build/${common.buildType}/test_properties`);
@@ -12,7 +13,7 @@ assert.strictEqual(test_object.readwriteValue, 1);
 test_object.readwriteValue = 2;
 assert.strictEqual(test_object.readwriteValue, 2);
 
-assert.throws(() => { test_object.readonlyValue = 3; }, TypeError);
+assert.throws(() => { test_object.readonlyValue = 3; }, readonlyErrorRE);
 
 assert.ok(test_object.hiddenValue);
 
@@ -42,11 +43,11 @@ assert.strictEqual(symbolDescription, 'NameKeySymbol');
 test_object.readwriteAccessor1 = 1;
 assert.strictEqual(test_object.readwriteAccessor1, 1);
 assert.strictEqual(test_object.readonlyAccessor1, 1);
-assert.throws(() => { test_object.readonlyAccessor1 = 3; }, TypeError);
+assert.throws(() => { test_object.readonlyAccessor1 = 3; }, readonlyErrorRE);
 test_object.readwriteAccessor2 = 2;
 assert.strictEqual(test_object.readwriteAccessor2, 2);
 assert.strictEqual(test_object.readonlyAccessor2, 2);
-assert.throws(() => { test_object.readonlyAccessor2 = 3; }, TypeError);
+assert.throws(() => { test_object.readonlyAccessor2 = 3; }, readonlyErrorRE);
 
 assert.strictEqual(test_object.hasNamedProperty(test_object, 'echo'), true);
 assert.strictEqual(test_object.hasNamedProperty(test_object, 'hiddenValue'),

From b5ef731373b45ccf6a26411740112bb274ba5333 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Thu, 13 Jul 2017 11:35:55 +0300
Subject: [PATCH 086/183] n-api: re-use napi_env between modules

Store the `napi_env` on the global object at a private key. This gives
us one `napi_env` per context.

Refs: https://github.com/nodejs/node/issues/14367
PR-URL: https://github.com/nodejs/node/pull/14217
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
---
 src/node_api.cc                               | 45 +++++++++++++++++--
 test/addons-napi/test_env_sharing/binding.gyp | 12 +++++
 .../test_env_sharing/compare_env.c            | 22 +++++++++
 test/addons-napi/test_env_sharing/store_env.c | 12 +++++
 test/addons-napi/test_env_sharing/test.js     | 10 +++++
 5 files changed, 98 insertions(+), 3 deletions(-)
 create mode 100644 test/addons-napi/test_env_sharing/binding.gyp
 create mode 100644 test/addons-napi/test_env_sharing/compare_env.c
 create mode 100644 test/addons-napi/test_env_sharing/store_env.c
 create mode 100644 test/addons-napi/test_env_sharing/test.js

diff --git a/src/node_api.cc b/src/node_api.cc
index 06f18562e7d3c0..3cdd4b8a970f28 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -712,6 +712,45 @@ bool FindWrapper(v8::Local<v8::Object> obj,
   return true;
 }
 
+static void DeleteEnv(napi_env env, void* data, void* hint) {
+  delete env;
+}
+
+napi_env GetEnv(v8::Local<v8::Context> context) {
+  napi_env result;
+
+  auto isolate = context->GetIsolate();
+  auto global = context->Global();
+
+  // In the case of the string for which we grab the private and the value of
+  // the private on the global object we can call .ToLocalChecked() directly
+  // because we need to stop hard if either of them is empty.
+  //
+  // Re https://github.com/nodejs/node/pull/14217#discussion_r128775149
+  auto key = v8::Private::ForApi(isolate,
+      v8::String::NewFromOneByte(isolate,
+          reinterpret_cast<const uint8_t*>("N-API Environment"),
+          v8::NewStringType::kInternalized).ToLocalChecked());
+  auto value = global->GetPrivate(context, key).ToLocalChecked();
+
+  if (value->IsExternal()) {
+    result = static_cast<napi_env>(value.As<v8::External>()->Value());
+  } else {
+    result = new napi_env__(isolate);
+    auto external = v8::External::New(isolate, result);
+
+    // We must also stop hard if the result of assigning the env to the global
+    // is either nothing or false.
+    CHECK(global->SetPrivate(context, key, external).FromJust());
+
+    // Create a self-destructing reference to external that will get rid of the
+    // napi_env when external goes out of scope.
+    Reference::New(result, external, 0, true, DeleteEnv, nullptr, nullptr);
+  }
+
+  return result;
+}
+
 }  // end of namespace v8impl
 
 // Intercepts the Node-V8 module registration callback. Converts parameters
@@ -723,9 +762,9 @@ void napi_module_register_cb(v8::Local<v8::Object> exports,
                              void* priv) {
   napi_module* mod = static_cast<napi_module*>(priv);
 
-  // Create a new napi_env for this module. Once module unloading is supported
-  // we shall have to call delete on this object from there.
-  napi_env env = new napi_env__(context->GetIsolate());
+  // Create a new napi_env for this module or reference one if a pre-existing
+  // one is found.
+  napi_env env = v8impl::GetEnv(context);
 
   mod->nm_register_func(
     env,
diff --git a/test/addons-napi/test_env_sharing/binding.gyp b/test/addons-napi/test_env_sharing/binding.gyp
new file mode 100644
index 00000000000000..5699a8391dd347
--- /dev/null
+++ b/test/addons-napi/test_env_sharing/binding.gyp
@@ -0,0 +1,12 @@
+{
+  "targets": [
+    {
+      "target_name": "store_env",
+      "sources": [ "store_env.c" ]
+    },
+    {
+      "target_name": "compare_env",
+      "sources": [ "compare_env.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_env_sharing/compare_env.c b/test/addons-napi/test_env_sharing/compare_env.c
new file mode 100644
index 00000000000000..b209c8f6d8e968
--- /dev/null
+++ b/test/addons-napi/test_env_sharing/compare_env.c
@@ -0,0 +1,22 @@
+#include <node_api.h>
+#include "../common.h"
+
+napi_value compare(napi_env env, napi_callback_info info) {
+  napi_value external;
+  size_t argc = 1;
+  void* data;
+  napi_value return_value;
+
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &external, NULL, NULL));
+  NAPI_CALL(env, napi_get_value_external(env, external, &data));
+  NAPI_CALL(env, napi_get_boolean(env, ((napi_env)data) == env, &return_value));
+
+  return return_value;
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* context) {
+  napi_property_descriptor prop = DECLARE_NAPI_PROPERTY("exports", compare);
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(env, module, 1, &prop));
+}
+
+NAPI_MODULE(compare_env, Init)
diff --git a/test/addons-napi/test_env_sharing/store_env.c b/test/addons-napi/test_env_sharing/store_env.c
new file mode 100644
index 00000000000000..391f6faa27648e
--- /dev/null
+++ b/test/addons-napi/test_env_sharing/store_env.c
@@ -0,0 +1,12 @@
+#include <node_api.h>
+#include "../common.h"
+
+void Init(napi_env env, napi_value exports, napi_value module, void* context) {
+  napi_value external;
+  NAPI_CALL_RETURN_VOID(env,
+    napi_create_external(env, env, NULL, NULL, &external));
+  NAPI_CALL_RETURN_VOID(env,
+    napi_set_named_property(env, module, "exports", external));
+}
+
+NAPI_MODULE(store_env, Init)
diff --git a/test/addons-napi/test_env_sharing/test.js b/test/addons-napi/test_env_sharing/test.js
new file mode 100644
index 00000000000000..6e21bf4c638b80
--- /dev/null
+++ b/test/addons-napi/test_env_sharing/test.js
@@ -0,0 +1,10 @@
+'use strict';
+
+const common = require('../../common');
+const storeEnv = require(`./build/${common.buildType}/store_env`);
+const compareEnv = require(`./build/${common.buildType}/compare_env`);
+const assert = require('assert');
+
+assert.strictEqual(compareEnv(storeEnv), true,
+                   'N-API environment pointers in two different modules have ' +
+                   'the same value');

From 1fe20045822e7b4cda1af10c9b2e1a03b9e1a0ca Mon Sep 17 00:00:00 2001
From: Shivanth MP <fordearlinux@gmail.com>
Date: Thu, 20 Jul 2017 01:50:43 +0530
Subject: [PATCH 087/183] n-api: add support for DataView

Basic support for Dataview is added in this commit. This is achieved
by using three functions, napi_create_dataview(), napi_is_dataview()
and napi_get_dataview_info().

PR-URL: https://github.com/nodejs/node/pull/14382
Fixes: https://github.com/nodejs/node/issues/13926
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 doc/api/n-api.md                              | 84 +++++++++++++++++++
 src/node_api.cc                               | 66 +++++++++++++++
 src/node_api.h                                | 15 ++++
 test/addons-napi/test_dataview/binding.gyp    |  8 ++
 test/addons-napi/test_dataview/test.js        | 14 ++++
 .../addons-napi/test_dataview/test_dataview.c | 49 +++++++++++
 6 files changed, 236 insertions(+)
 create mode 100644 test/addons-napi/test_dataview/binding.gyp
 create mode 100644 test/addons-napi/test_dataview/test.js
 create mode 100644 test/addons-napi/test_dataview/test_dataview.c

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 91780846ff2e4a..8f8aa76f83ac7b 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -1331,6 +1331,40 @@ JavaScript TypedArray Objects are described in
 [Section 22.2](https://tc39.github.io/ecma262/#sec-typedarray-objects)
 of the ECMAScript Language Specification.
 
+
+#### *napi_create_dataview*
+<!-- YAML
+added: REPLACEME
+-->
+
+```C
+napi_status napi_create_dataview(napi_env env,
+                                 size_t byte_length,
+                                 napi_value arraybuffer,
+                                 size_t byte_offset,
+                                 napi_value* result)
+
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] length`: Number of elements in the DataView.
+- `[in] arraybuffer`: ArrayBuffer underlying the DataView.
+- `[in] byte_offset`: The byte offset within the ArrayBuffer from which to
+  start projecting the DataView.
+- `[out] result`: A `napi_value` representing a JavaScript DataView.
+
+Returns `napi_ok` if the API succeeded.
+
+This API creates a JavaScript DataView object over an existing ArrayBuffer.
+DataView objects provide an array-like view over an underlying data buffer,
+but one which allows items of different size and type in the ArrayBuffer.
+
+It is required that `byte_length + byte_offset` is less than or equal to the
+size in bytes of the array passed in. If not, a RangeError exception is raised.
+
+JavaScript DataView Objects are described in
+[Section 24.3][] of the ECMAScript Language Specification.
+
 ### Functions to convert from C types to N-API
 #### *napi_create_number*
 <!-- YAML
@@ -1552,6 +1586,36 @@ This API returns various properties of a typed array.
 *Warning*: Use caution while using this API since the underlying data buffer
 is managed by the VM
 
+
+
+#### *napi_get_dataview_info*
+<!-- YAML
+added: REPLACEME
+-->
+
+```C
+napi_status napi_get_dataview_info(napi_env env,
+                                   napi_value dataview,
+                                   size_t* byte_length,
+                                   void** data,
+                                   napi_value* arraybuffer,
+                                   size_t* byte_offset)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] dataview`: `napi_value` representing the DataView whose
+  properties to query.
+- `[out] byte_length`: Number of bytes in the DataView.
+- `[out] data`: The data buffer underlying the DataView.
+- `[out] arraybuffer`: ArrayBuffer underlying the DataView.
+- `[out] byte_offset`: The byte offset within the data buffer from which
+  to start projecting the DataView.
+
+Returns `napi_ok` if the API succeeded.
+
+This API returns various properties of a DataView.
+
+
 #### *napi_get_value_bool*
 <!-- YAML
 added: v8.0.0
@@ -2019,6 +2083,25 @@ Returns `napi_ok` if the API succeeded.
 
 This API checks if the Object passsed in is a typed array.
 
+
+
+### *napi_is_dataview*
+<!-- YAML
+added: REPLACEME
+-->
+
+```C
+napi_status napi_is_dataview(napi_env env, napi_value value, bool* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: The JavaScript value to check.
+- `[out] result`: Whether the given `napi_value` represents a DataView.
+
+Returns `napi_ok` if the API succeeded.
+
+This API checks if the Object passed in is a DataView.
+
 ### *napi_strict_equals*
 <!-- YAML
 added: v8.0.0
@@ -3165,6 +3248,7 @@ support it:
 [Object Wrap]: #n_api_object_wrap
 [Section 9.1.6]: https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-defineownproperty-p-desc
 [Section 12.5.5]: https://tc39.github.io/ecma262/#sec-typeof-operator
+[Section 24.3]: https://tc39.github.io/ecma262/#sec-dataview-objects
 [Working with JavaScript Functions]: #n_api_working_with_javascript_functions
 [Working with JavaScript Properties]: #n_api_working_with_javascript_properties
 [Working with JavaScript Values]: #n_api_working_with_javascript_values
diff --git a/src/node_api.cc b/src/node_api.cc
index 3cdd4b8a970f28..08bbede084c97b 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -3019,6 +3019,72 @@ napi_status napi_get_typedarray_info(napi_env env,
   return napi_clear_last_error(env);
 }
 
+napi_status napi_create_dataview(napi_env env,
+                                 size_t byte_length,
+                                 napi_value arraybuffer,
+                                 size_t byte_offset,
+                                 napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(env, arraybuffer);
+  CHECK_ARG(env, result);
+
+  v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(arraybuffer);
+  RETURN_STATUS_IF_FALSE(env, value->IsArrayBuffer(), napi_invalid_arg);
+
+  v8::Local<v8::ArrayBuffer> buffer = value.As<v8::ArrayBuffer>();
+  v8::Local<v8::DataView> DataView = v8::DataView::New(buffer, byte_offset,
+                                                       byte_length);
+
+  *result = v8impl::JsValueFromV8LocalValue(DataView);
+  return GET_RETURN_STATUS(env);
+}
+
+napi_status napi_is_dataview(napi_env env, napi_value value, bool* result) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, value);
+  CHECK_ARG(env, result);
+
+  v8::Local<v8::Value> val = v8impl::V8LocalValueFromJsValue(value);
+  *result = val->IsDataView();
+
+  return napi_clear_last_error(env);
+}
+
+napi_status napi_get_dataview_info(napi_env env,
+                                   napi_value dataview,
+                                   size_t* byte_length,
+                                   void** data,
+                                   napi_value* arraybuffer,
+                                   size_t* byte_offset) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, dataview);
+
+  v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(dataview);
+  RETURN_STATUS_IF_FALSE(env, value->IsDataView(), napi_invalid_arg);
+
+  v8::Local<v8::DataView> array = value.As<v8::DataView>();
+
+  if (byte_length != nullptr) {
+    *byte_length = array->ByteLength();
+  }
+
+  v8::Local<v8::ArrayBuffer> buffer = array->Buffer();
+  if (data != nullptr) {
+    *data = static_cast<uint8_t*>(buffer->GetContents().Data()) +
+            array->ByteOffset();
+  }
+
+  if (arraybuffer != nullptr) {
+    *arraybuffer = v8impl::JsValueFromV8LocalValue(buffer);
+  }
+
+  if (byte_offset != nullptr) {
+    *byte_offset = array->ByteOffset();
+  }
+
+  return napi_clear_last_error(env);
+}
+
 napi_status napi_get_version(napi_env env, uint32_t* result) {
   CHECK_ENV(env);
   CHECK_ARG(env, result);
diff --git a/src/node_api.h b/src/node_api.h
index f4d097ad104cf9..5a2ba946ec8114 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -494,6 +494,21 @@ NAPI_EXTERN napi_status napi_get_typedarray_info(napi_env env,
                                                  napi_value* arraybuffer,
                                                  size_t* byte_offset);
 
+NAPI_EXTERN napi_status napi_create_dataview(napi_env env,
+                                             size_t length,
+                                             napi_value arraybuffer,
+                                             size_t byte_offset,
+                                             napi_value* result);
+NAPI_EXTERN napi_status napi_is_dataview(napi_env env,
+                                         napi_value value,
+                                         bool* result);
+NAPI_EXTERN napi_status napi_get_dataview_info(napi_env env,
+                                               napi_value dataview,
+                                               size_t* bytelength,
+                                               void** data,
+                                               napi_value* arraybuffer,
+                                               size_t* byte_offset);
+
 // Methods to manage simple async operations
 NAPI_EXTERN
 napi_status napi_create_async_work(napi_env env,
diff --git a/test/addons-napi/test_dataview/binding.gyp b/test/addons-napi/test_dataview/binding.gyp
new file mode 100644
index 00000000000000..bf014dc9e7b373
--- /dev/null
+++ b/test/addons-napi/test_dataview/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_dataview",
+      "sources": [ "test_dataview.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_dataview/test.js b/test/addons-napi/test_dataview/test.js
new file mode 100644
index 00000000000000..87cf8159ab8635
--- /dev/null
+++ b/test/addons-napi/test_dataview/test.js
@@ -0,0 +1,14 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+
+// Testing api calls for arrays
+const test_dataview = require(`./build/${common.buildType}/test_dataview`);
+
+//create dataview
+const buffer = new ArrayBuffer(128);
+const template = Reflect.construct(DataView, [buffer]);
+
+const theDataview = test_dataview.CreateDataView(template);
+assert.ok(theDataview instanceof DataView,
+          'The new variable should be of type Dataview');
diff --git a/test/addons-napi/test_dataview/test_dataview.c b/test/addons-napi/test_dataview/test_dataview.c
new file mode 100644
index 00000000000000..4060e4d2666c44
--- /dev/null
+++ b/test/addons-napi/test_dataview/test_dataview.c
@@ -0,0 +1,49 @@
+#include <node_api.h>
+#include <string.h>
+#include "../common.h"
+
+napi_value CreateDataView(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args [1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc == 1, "Wrong number of arguments");
+
+  napi_valuetype valuetype;
+  napi_value input_dataview = args[0];
+
+  NAPI_CALL(env, napi_typeof(env, input_dataview, &valuetype));
+  NAPI_ASSERT(env, valuetype == napi_object,
+              "Wrong type of arguments. Expects a DataView as the first "
+              "argument.");
+
+  bool is_dataview;
+  NAPI_CALL(env, napi_is_dataview(env, input_dataview, &is_dataview));
+  NAPI_ASSERT(env, is_dataview,
+              "Wrong type of arguments. Expects a DataView as the first "
+              "argument.");
+  size_t byte_offset = 0;
+  size_t length = 0;
+  napi_value buffer;
+  NAPI_CALL(env,
+            napi_get_dataview_info(env, input_dataview, &length, NULL,
+                                   &buffer, &byte_offset));
+
+  napi_value output_dataview;
+  NAPI_CALL(env,
+            napi_create_dataview(env, length, buffer,
+                                 byte_offset, &output_dataview));
+
+  return output_dataview;
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_property_descriptor descriptors[] = {
+    DECLARE_NAPI_PROPERTY("CreateDataView", CreateDataView)
+  };
+
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+}
+
+NAPI_MODULE(addon, Init)

From fb41b0152e15d4d0ae0952e8ca2f41c405e2251e Mon Sep 17 00:00:00 2001
From: cjihrig <cjihrig@gmail.com>
Date: Fri, 14 Jul 2017 10:26:45 -0400
Subject: [PATCH 088/183] doc: document napi_finalize() signature
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Refs: https://github.com/nodejs/node/issues/14138
PR-URL: https://github.com/nodejs/node/pull/14230
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Gibson Fahnestock <gibfahn@gmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
---
 doc/api/n-api.md | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 8f8aa76f83ac7b..0b7294d5bd495e 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -181,6 +181,12 @@ must provide a function satisfying the following signature which would get
 called upon the object's collection. Currently, `napi_finalize` can be used for
 finding out when objects that have external data are collected.
 
+```C
+typedef void (*napi_finalize)(napi_env env,
+                              void* finalize_data,
+                              void* finalize_hint);
+```
+
 
 #### napi_async_execute_callback
 Function pointer used with functions that support asynchronous

From 3be9e951001da2b270de9188d370bc028a02cc54 Mon Sep 17 00:00:00 2001
From: Ben Noordhuis <info@bnoordhuis.nl>
Date: Thu, 27 Jul 2017 17:33:35 +0200
Subject: [PATCH 089/183] src: replace assert with CHECK_LE in node_api.cc
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/14514
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Richard Lau <riclau@uk.ibm.com>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
Reviewed-By: Tobias Nie�en <tniessen@tnie.de>
---
 src/node_api.cc | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 08bbede084c97b..932ec858963558 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -13,7 +13,6 @@
 
 #include <string.h>
 #include <algorithm>
-#include <cassert>
 #include <cmath>
 #include <vector>
 #include "uv.h"
@@ -855,7 +854,7 @@ napi_status napi_get_last_error_info(napi_env env,
   static_assert(
       node::arraysize(error_messages) == napi_escape_called_twice + 1,
       "Count of error messages must match count of error values");
-  assert(env->last_error.error_code <= napi_escape_called_twice);
+  CHECK_LE(env->last_error.error_code, napi_escape_called_twice);
 
   // Wait until someone requests the last error information to fetch the error
   // message string

From 2ae281eb1e28aefe75cd1c7a3e305310c6979d91 Mon Sep 17 00:00:00 2001
From: Jason Ginchereau <jasongin@microsoft.com>
Date: Tue, 18 Jul 2017 20:22:35 -0700
Subject: [PATCH 090/183] n-api: optimize number API performance

 - Add separate APIs for creating different kinds of numbers,
   because creating a V8 number value from an integer is faster
   than creating one from a double.
 - When getting number values, avoid getting the current context
   because the context will not actually be used and is expensive
   to obtain.
 - When creating values, don't use v8::TryCatch (NAPI_PREAMBLE),
   because these functions have no possibility of executing JS code.

Refs: https://github.com/nodejs/node/issues/14379
PR-URL: https://github.com/nodejs/node/pull/14573
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 doc/api/n-api.md                              |  85 ++++++++++--
 src/node_api.cc                               | 131 +++++++++++-------
 src/node_api.h                                |  11 +-
 .../2_function_arguments/binding.c            |   2 +-
 test/addons-napi/6_object_wrap/myobject.cc    |   6 +-
 test/addons-napi/7_factory_wrap/myobject.cc   |   4 +-
 test/addons-napi/7_factory_wrap/myobject.h    |   2 +-
 test/addons-napi/8_passing_wrapped/binding.cc |   2 +-
 test/addons-napi/test_async/test_async.cc     |   2 +-
 test/addons-napi/test_buffer/test_buffer.c    |   2 +-
 .../test_constructor/test_constructor.c       |   6 +-
 .../test_conversions/test_conversions.c       |   8 +-
 test/addons-napi/test_general/test_general.c  |   2 +-
 test/addons-napi/test_number/test_number.c    |   4 +-
 test/addons-napi/test_object/test_object.c    |   4 +-
 .../test_properties/test_properties.c         |   4 +-
 .../test_reference/test_reference.c           |   6 +-
 test/addons-napi/test_string/test_string.c    |   4 +-
 18 files changed, 197 insertions(+), 88 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 0b7294d5bd495e..5b7c97d15af6a5 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -1372,12 +1372,81 @@ JavaScript DataView Objects are described in
 [Section 24.3][] of the ECMAScript Language Specification.
 
 ### Functions to convert from C types to N-API
-#### *napi_create_number*
+#### *napi_create_int32*
 <!-- YAML
-added: v8.0.0
+added: REPLACEME
+-->
+```C
+napi_status napi_create_int32(napi_env env, int32_t value, napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: Integer value to be represented in JavaScript.
+- `[out] result`: A `napi_value` representing a JavaScript Number.
+
+Returns `napi_ok` if the API succeeded.
+
+This API is used to convert from the C `int32_t` type to the JavaScript
+Number type.
+
+The JavaScript Number type is described in
+[Section 6.1.6](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type)
+of the ECMAScript Language Specification.
+
+#### *napi_create_uint32*
+<!-- YAML
+added: REPLACEME
+-->
+```C
+napi_status napi_create_uint32(napi_env env, uint32_t value, napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: Unsigned integer value to be represented in JavaScript.
+- `[out] result`: A `napi_value` representing a JavaScript Number.
+
+Returns `napi_ok` if the API succeeded.
+
+This API is used to convert from the C `uint32_t` type to the JavaScript
+Number type.
+
+The JavaScript Number type is described in
+[Section 6.1.6](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type)
+of the ECMAScript Language Specification.
+
+#### *napi_create_int64*
+<!-- YAML
+added: REPLACEME
+-->
+```C
+napi_status napi_create_int64(napi_env env, int64_t value, napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: Integer value to be represented in JavaScript.
+- `[out] result`: A `napi_value` representing a JavaScript Number.
+
+Returns `napi_ok` if the API succeeded.
+
+This API is used to convert from the C `int64_t` type to the JavaScript
+Number type.
+
+The JavaScript Number type is described in
+[Section 6.1.6](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type)
+of the ECMAScript Language Specification. Note the complete range of `int64_t`
+cannot be represented with full precision in JavaScript. Integer values
+outside the range of
+[`Number.MIN_SAFE_INTEGER`](https://tc39.github.io/ecma262/#sec-number.min_safe_integer)
+-(2^53 - 1) -
+[`Number.MAX_SAFE_INTEGER`](https://tc39.github.io/ecma262/#sec-number.max_safe_integer)
+(2^53 - 1) will lose precision.
+
+#### *napi_create_double*
+<!-- YAML
+added: REPLACEME
 -->
 ```C
-napi_status napi_create_number(napi_env env, double value, napi_value* result)
+napi_status napi_create_double(napi_env env, double value, napi_value* result)
 ```
 
 - `[in] env`: The environment that the API is invoked under.
@@ -1386,7 +1455,7 @@ napi_status napi_create_number(napi_env env, double value, napi_value* result)
 
 Returns `napi_ok` if the API succeeded.
 
-This API is used to convert from the C double type to the JavaScript
+This API is used to convert from the C `double` type to the JavaScript
 Number type.
 
 The JavaScript Number type is described in
@@ -2170,7 +2239,7 @@ status = napi_create_object(env, &obj);
 if (status != napi_ok) return status;
 
 // Create a napi_value for 123
-status = napi_create_number(env, 123, &value);
+status = napi_create_int32(env, 123, &value);
 if (status != napi_ok) return status;
 
 // obj.myProp = 123
@@ -2244,9 +2313,9 @@ if (status != napi_ok) return status;
 
 // Create napi_values for 123 and 456
 napi_value fooValue, barValue;
-status = napi_create_number(env, 123, &fooValue);
+status = napi_create_int32(env, 123, &fooValue);
 if (status != napi_ok) return status;
-status = napi_create_number(env, 456, &barValue);
+status = napi_create_int32(env, 456, &barValue);
 if (status != napi_ok) return status;
 
 // Set the properties
@@ -2707,7 +2776,7 @@ status = napi_get_named_property(env, global, "AddTwo", &add_two);
 if (status != napi_ok) return;
 
 // const arg = 1337
-status = napi_create_number(env, 1337, &arg);
+status = napi_create_int32(env, 1337, &arg);
 if (status != napi_ok) return;
 
 napi_value* argv = &arg;
diff --git a/src/node_api.cc b/src/node_api.cc
index 932ec858963558..948f6afef55291 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -821,9 +821,7 @@ const char* error_messages[] = {nullptr,
                                 "The async work item was cancelled",
                                 "napi_escape_handle already called on scope"};
 
-static napi_status napi_clear_last_error(napi_env env) {
-  CHECK_ENV(env);
-
+static inline napi_status napi_clear_last_error(napi_env env) {
   env->last_error.error_code = napi_ok;
 
   // TODO(boingoing): Should this be a callback?
@@ -832,13 +830,13 @@ static napi_status napi_clear_last_error(napi_env env) {
   return napi_ok;
 }
 
-static napi_status napi_set_last_error(napi_env env, napi_status error_code,
-                                       uint32_t engine_error_code,
-                                       void* engine_reserved) {
+static inline
+napi_status napi_set_last_error(napi_env env, napi_status error_code,
+                                uint32_t engine_error_code,
+                                void* engine_reserved) {
   env->last_error.error_code = error_code;
   env->last_error.engine_error_code = engine_error_code;
   env->last_error.engine_reserved = engine_reserved;
-
   return error_code;
 }
 
@@ -1439,42 +1437,42 @@ napi_status napi_get_prototype(napi_env env,
 }
 
 napi_status napi_create_object(napi_env env, napi_value* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, result);
 
   *result = v8impl::JsValueFromV8LocalValue(
       v8::Object::New(env->isolate));
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_create_array(napi_env env, napi_value* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, result);
 
   *result = v8impl::JsValueFromV8LocalValue(
       v8::Array::New(env->isolate));
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_create_array_with_length(napi_env env,
                                           size_t length,
                                           napi_value* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, result);
 
   *result = v8impl::JsValueFromV8LocalValue(
       v8::Array::New(env->isolate, length));
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_create_string_latin1(napi_env env,
                                       const char* str,
                                       size_t length,
                                       napi_value* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, result);
 
   auto isolate = env->isolate;
@@ -1486,28 +1484,28 @@ napi_status napi_create_string_latin1(napi_env env,
   CHECK_MAYBE_EMPTY(env, str_maybe, napi_generic_failure);
 
   *result = v8impl::JsValueFromV8LocalValue(str_maybe.ToLocalChecked());
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_create_string_utf8(napi_env env,
                                     const char* str,
                                     size_t length,
                                     napi_value* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, result);
 
   v8::Local<v8::String> s;
   CHECK_NEW_FROM_UTF8_LEN(env, s, str, length);
 
   *result = v8impl::JsValueFromV8LocalValue(s);
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_create_string_utf16(napi_env env,
                                      const char16_t* str,
                                      size_t length,
                                      napi_value* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, result);
 
   auto isolate = env->isolate;
@@ -1519,19 +1517,55 @@ napi_status napi_create_string_utf16(napi_env env,
   CHECK_MAYBE_EMPTY(env, str_maybe, napi_generic_failure);
 
   *result = v8impl::JsValueFromV8LocalValue(str_maybe.ToLocalChecked());
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
-napi_status napi_create_number(napi_env env,
+napi_status napi_create_double(napi_env env,
                                double value,
                                napi_value* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, result);
 
   *result = v8impl::JsValueFromV8LocalValue(
       v8::Number::New(env->isolate, value));
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
+}
+
+napi_status napi_create_int32(napi_env env,
+                              int32_t value,
+                              napi_value* result) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
+
+  *result = v8impl::JsValueFromV8LocalValue(
+      v8::Integer::New(env->isolate, value));
+
+  return napi_clear_last_error(env);
+}
+
+napi_status napi_create_uint32(napi_env env,
+                               uint32_t value,
+                               napi_value* result) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
+
+  *result = v8impl::JsValueFromV8LocalValue(
+      v8::Integer::NewFromUnsigned(env->isolate, value));
+
+  return napi_clear_last_error(env);
+}
+
+napi_status napi_create_int64(napi_env env,
+                              int64_t value,
+                              napi_value* result) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
+
+  *result = v8impl::JsValueFromV8LocalValue(
+      v8::Number::New(env->isolate, static_cast<double>(value)));
+
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_get_boolean(napi_env env, bool value, napi_value* result) {
@@ -1552,7 +1586,7 @@ napi_status napi_get_boolean(napi_env env, bool value, napi_value* result) {
 napi_status napi_create_symbol(napi_env env,
                                napi_value description,
                                napi_value* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, result);
 
   v8::Isolate* isolate = env->isolate;
@@ -1567,7 +1601,7 @@ napi_status napi_create_symbol(napi_env env,
       v8::Symbol::New(isolate, desc.As<v8::String>()));
   }
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 static napi_status set_error_code(napi_env env,
@@ -1627,7 +1661,7 @@ napi_status napi_create_error(napi_env env,
                               napi_value code,
                               napi_value msg,
                               napi_value* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, msg);
   CHECK_ARG(env, result);
 
@@ -1641,14 +1675,14 @@ napi_status napi_create_error(napi_env env,
 
   *result = v8impl::JsValueFromV8LocalValue(error_obj);
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_create_type_error(napi_env env,
                                    napi_value code,
                                    napi_value msg,
                                    napi_value* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, msg);
   CHECK_ARG(env, result);
 
@@ -1662,14 +1696,14 @@ napi_status napi_create_type_error(napi_env env,
 
   *result = v8impl::JsValueFromV8LocalValue(error_obj);
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_create_range_error(napi_env env,
                                     napi_value code,
                                     napi_value msg,
                                     napi_value* result) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, msg);
   CHECK_ARG(env, result);
 
@@ -1683,7 +1717,7 @@ napi_status napi_create_range_error(napi_env env,
 
   *result = v8impl::JsValueFromV8LocalValue(error_obj);
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_typeof(napi_env env,
@@ -1954,14 +1988,13 @@ napi_status napi_get_value_int32(napi_env env,
 
   if (val->IsInt32()) {
     *result = val.As<v8::Int32>()->Value();
-    return napi_clear_last_error(env);
-  }
-
-  RETURN_STATUS_IF_FALSE(env, val->IsNumber(), napi_number_expected);
+  } else {
+    RETURN_STATUS_IF_FALSE(env, val->IsNumber(), napi_number_expected);
 
-  v8::Isolate* isolate = env->isolate;
-  v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  *result = val->Int32Value(context).FromJust();
+    // Empty context: https://github.com/nodejs/node/issues/14379
+    v8::Local<v8::Context> context;
+    *result = val->Int32Value(context).FromJust();
+  }
 
   return napi_clear_last_error(env);
 }
@@ -1979,14 +2012,13 @@ napi_status napi_get_value_uint32(napi_env env,
 
   if (val->IsUint32()) {
     *result = val.As<v8::Uint32>()->Value();
-    return napi_clear_last_error(env);
-  }
-
-  RETURN_STATUS_IF_FALSE(env, val->IsNumber(), napi_number_expected);
+  } else {
+    RETURN_STATUS_IF_FALSE(env, val->IsNumber(), napi_number_expected);
 
-  v8::Isolate* isolate = env->isolate;
-  v8::Local<v8::Context> context = isolate->GetCurrentContext();
-  *result = val->Uint32Value(context).FromJust();
+    // Empty context: https://github.com/nodejs/node/issues/14379
+    v8::Local<v8::Context> context;
+    *result = val->Uint32Value(context).FromJust();
+  }
 
   return napi_clear_last_error(env);
 }
@@ -2016,8 +2048,8 @@ napi_status napi_get_value_int64(napi_env env,
   if (std::isnan(doubleValue)) {
     *result = 0;
   } else {
-    v8::Isolate* isolate = env->isolate;
-    v8::Local<v8::Context> context = isolate->GetCurrentContext();
+    // Empty context: https://github.com/nodejs/node/issues/14379
+    v8::Local<v8::Context> context;
     *result = val->IntegerValue(context).FromJust();
   }
 
@@ -2796,11 +2828,10 @@ napi_status napi_get_buffer_info(napi_env env,
                                  napi_value value,
                                  void** data,
                                  size_t* length) {
-  NAPI_PREAMBLE(env);
+  CHECK_ENV(env);
   CHECK_ARG(env, value);
 
-  v8::Local<v8::Object> buffer =
-      v8impl::V8LocalValueFromJsValue(value).As<v8::Object>();
+  v8::Local<v8::Value> buffer = v8impl::V8LocalValueFromJsValue(value);
 
   if (data != nullptr) {
     *data = node::Buffer::Data(buffer);
@@ -2809,7 +2840,7 @@ napi_status napi_get_buffer_info(napi_env env,
     *length = node::Buffer::Length(buffer);
   }
 
-  return GET_RETURN_STATUS(env);
+  return napi_clear_last_error(env);
 }
 
 napi_status napi_is_arraybuffer(napi_env env, napi_value value, bool* result) {
diff --git a/src/node_api.h b/src/node_api.h
index 5a2ba946ec8114..cf4128be210fe7 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -127,9 +127,18 @@ NAPI_EXTERN napi_status napi_create_array(napi_env env, napi_value* result);
 NAPI_EXTERN napi_status napi_create_array_with_length(napi_env env,
                                                       size_t length,
                                                       napi_value* result);
-NAPI_EXTERN napi_status napi_create_number(napi_env env,
+NAPI_EXTERN napi_status napi_create_double(napi_env env,
                                            double value,
                                            napi_value* result);
+NAPI_EXTERN napi_status napi_create_int32(napi_env env,
+                                          int32_t value,
+                                          napi_value* result);
+NAPI_EXTERN napi_status napi_create_uint32(napi_env env,
+                                           uint32_t value,
+                                           napi_value* result);
+NAPI_EXTERN napi_status napi_create_int64(napi_env env,
+                                          int64_t value,
+                                          napi_value* result);
 NAPI_EXTERN napi_status napi_create_string_latin1(napi_env env,
                                                   const char* str,
                                                   size_t length,
diff --git a/test/addons-napi/2_function_arguments/binding.c b/test/addons-napi/2_function_arguments/binding.c
index a5ccac7b61c458..92f89fd2ffa199 100644
--- a/test/addons-napi/2_function_arguments/binding.c
+++ b/test/addons-napi/2_function_arguments/binding.c
@@ -24,7 +24,7 @@ napi_value Add(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_get_value_double(env, args[1], &value1));
 
   napi_value sum;
-  NAPI_CALL(env, napi_create_number(env, value0 + value1, &sum));
+  NAPI_CALL(env, napi_create_double(env, value0 + value1, &sum));
 
   return sum;
 }
diff --git a/test/addons-napi/6_object_wrap/myobject.cc b/test/addons-napi/6_object_wrap/myobject.cc
index c2557facc06382..56b00ddae49a32 100644
--- a/test/addons-napi/6_object_wrap/myobject.cc
+++ b/test/addons-napi/6_object_wrap/myobject.cc
@@ -86,7 +86,7 @@ napi_value MyObject::GetValue(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_unwrap(env, _this, reinterpret_cast<void**>(&obj)));
 
   napi_value num;
-  NAPI_CALL(env, napi_create_number(env, obj->value_, &num));
+  NAPI_CALL(env, napi_create_double(env, obj->value_, &num));
 
   return num;
 }
@@ -116,7 +116,7 @@ napi_value MyObject::PlusOne(napi_env env, napi_callback_info info) {
   obj->value_ += 1;
 
   napi_value num;
-  NAPI_CALL(env, napi_create_number(env, obj->value_, &num));
+  NAPI_CALL(env, napi_create_double(env, obj->value_, &num));
 
   return num;
 }
@@ -140,7 +140,7 @@ napi_value MyObject::Multiply(napi_env env, napi_callback_info info) {
 
   const int kArgCount = 1;
   napi_value argv[kArgCount];
-  NAPI_CALL(env, napi_create_number(env, obj->value_ * multiple, argv));
+  NAPI_CALL(env, napi_create_double(env, obj->value_ * multiple, argv));
 
   napi_value instance;
   NAPI_CALL(env, napi_new_instance(env, cons, kArgCount, argv, &instance));
diff --git a/test/addons-napi/7_factory_wrap/myobject.cc b/test/addons-napi/7_factory_wrap/myobject.cc
index d6b374d7bb7ff8..4a2b284439ddb9 100644
--- a/test/addons-napi/7_factory_wrap/myobject.cc
+++ b/test/addons-napi/7_factory_wrap/myobject.cc
@@ -45,7 +45,7 @@ napi_value MyObject::New(napi_env env, napi_callback_info info) {
   if (valuetype == napi_undefined) {
     obj->counter_ = 0;
   } else {
-    NAPI_CALL(env, napi_get_value_double(env, args[0], &obj->counter_));
+    NAPI_CALL(env, napi_get_value_uint32(env, args[0], &obj->counter_));
   }
 
   obj->env_ = env;
@@ -88,7 +88,7 @@ napi_value MyObject::PlusOne(napi_env env, napi_callback_info info) {
   obj->counter_ += 1;
 
   napi_value num;
-  NAPI_CALL(env, napi_create_number(env, obj->counter_, &num));
+  NAPI_CALL(env, napi_create_uint32(env, obj->counter_, &num));
 
   return num;
 }
diff --git a/test/addons-napi/7_factory_wrap/myobject.h b/test/addons-napi/7_factory_wrap/myobject.h
index c0b8522c609c4c..28ca94d16e30dd 100644
--- a/test/addons-napi/7_factory_wrap/myobject.h
+++ b/test/addons-napi/7_factory_wrap/myobject.h
@@ -18,7 +18,7 @@ class MyObject {
   static napi_ref constructor;
   static napi_value New(napi_env env, napi_callback_info info);
   static napi_value PlusOne(napi_env env, napi_callback_info info);
-  double counter_;
+  uint32_t counter_;
   napi_env env_;
   napi_ref wrapper_;
 };
diff --git a/test/addons-napi/8_passing_wrapped/binding.cc b/test/addons-napi/8_passing_wrapped/binding.cc
index 581638bdfa2b07..c22ac6442f6c4e 100644
--- a/test/addons-napi/8_passing_wrapped/binding.cc
+++ b/test/addons-napi/8_passing_wrapped/binding.cc
@@ -24,7 +24,7 @@ napi_value Add(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_unwrap(env, args[1], reinterpret_cast<void**>(&obj2)));
 
   napi_value sum;
-  NAPI_CALL(env, napi_create_number(env, obj1->Val() + obj2->Val(), &sum));
+  NAPI_CALL(env, napi_create_double(env, obj1->Val() + obj2->Val(), &sum));
 
   return sum;
 }
diff --git a/test/addons-napi/test_async/test_async.cc b/test/addons-napi/test_async/test_async.cc
index f257b268b93159..ca76fa2d33b132 100644
--- a/test/addons-napi/test_async/test_async.cc
+++ b/test/addons-napi/test_async/test_async.cc
@@ -52,7 +52,7 @@ void Complete(napi_env env, napi_status status, void* data) {
   napi_value argv[2];
 
   NAPI_CALL_RETURN_VOID(env, napi_get_null(env, &argv[0]));
-  NAPI_CALL_RETURN_VOID(env, napi_create_number(env, c->_output, &argv[1]));
+  NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, c->_output, &argv[1]));
   napi_value callback;
   NAPI_CALL_RETURN_VOID(env,
     napi_get_reference_value(env, c->_callback, &callback));
diff --git a/test/addons-napi/test_buffer/test_buffer.c b/test/addons-napi/test_buffer/test_buffer.c
index 880149e1ff8561..0e12bedfb5602f 100644
--- a/test/addons-napi/test_buffer/test_buffer.c
+++ b/test/addons-napi/test_buffer/test_buffer.c
@@ -55,7 +55,7 @@ napi_value newExternalBuffer(napi_env env, napi_callback_info info) {
 
 napi_value getDeleterCallCount(napi_env env, napi_callback_info info) {
   napi_value callCount;
-  NAPI_CALL(env, napi_create_number(env, deleterCallCount, &callCount));
+  NAPI_CALL(env, napi_create_int32(env, deleterCallCount, &callCount));
   return callCount;
 }
 
diff --git a/test/addons-napi/test_constructor/test_constructor.c b/test/addons-napi/test_constructor/test_constructor.c
index 220d564753ca10..a991dab8533bf1 100644
--- a/test/addons-napi/test_constructor/test_constructor.c
+++ b/test/addons-napi/test_constructor/test_constructor.c
@@ -12,7 +12,7 @@ napi_value GetValue(napi_env env, napi_callback_info info) {
   NAPI_ASSERT(env, argc == 0, "Wrong number of arguments");
 
   napi_value number;
-  NAPI_CALL(env, napi_create_number(env, value_, &number));
+  NAPI_CALL(env, napi_create_double(env, value_, &number));
 
   return number;
 }
@@ -53,7 +53,7 @@ napi_value GetStaticValue(napi_env env, napi_callback_info info) {
   NAPI_ASSERT(env, argc == 0, "Wrong number of arguments");
 
   napi_value number;
-  NAPI_CALL(env, napi_create_number(env, static_value_, &number));
+  NAPI_CALL(env, napi_create_double(env, static_value_, &number));
 
   return number;
 }
@@ -61,7 +61,7 @@ napi_value GetStaticValue(napi_env env, napi_callback_info info) {
 
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_value number;
-  NAPI_CALL_RETURN_VOID(env, napi_create_number(env, value_, &number));
+  NAPI_CALL_RETURN_VOID(env, napi_create_double(env, value_, &number));
 
   napi_property_descriptor properties[] = {
     { "echo", 0, Echo, 0, 0, 0, napi_enumerable, 0 },
diff --git a/test/addons-napi/test_conversions/test_conversions.c b/test/addons-napi/test_conversions/test_conversions.c
index 637cff43b82c4d..a8d526c763c9a2 100644
--- a/test/addons-napi/test_conversions/test_conversions.c
+++ b/test/addons-napi/test_conversions/test_conversions.c
@@ -24,7 +24,7 @@ napi_value AsInt32(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_get_value_int32(env, args[0], &value));
 
   napi_value output;
-  NAPI_CALL(env, napi_create_number(env, value, &output));
+  NAPI_CALL(env, napi_create_int32(env, value, &output));
 
   return output;
 }
@@ -38,7 +38,7 @@ napi_value AsUInt32(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_get_value_uint32(env, args[0], &value));
 
   napi_value output;
-  NAPI_CALL(env, napi_create_number(env, value, &output));
+  NAPI_CALL(env, napi_create_uint32(env, value, &output));
 
   return output;
 }
@@ -52,7 +52,7 @@ napi_value AsInt64(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_get_value_int64(env, args[0], &value));
 
   napi_value output;
-  NAPI_CALL(env, napi_create_number(env, (double)value, &output));
+  NAPI_CALL(env, napi_create_int64(env, (double)value, &output));
 
   return output;
 }
@@ -66,7 +66,7 @@ napi_value AsDouble(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_get_value_double(env, args[0], &value));
 
   napi_value output;
-  NAPI_CALL(env, napi_create_number(env, value, &output));
+  NAPI_CALL(env, napi_create_double(env, value, &output));
 
   return output;
 }
diff --git a/test/addons-napi/test_general/test_general.c b/test/addons-napi/test_general/test_general.c
index 2d2d13a3624e6e..858611939474b2 100644
--- a/test/addons-napi/test_general/test_general.c
+++ b/test/addons-napi/test_general/test_general.c
@@ -29,7 +29,7 @@ napi_value testGetVersion(napi_env env, napi_callback_info info) {
   uint32_t version;
   napi_value result;
   NAPI_CALL(env, napi_get_version(env, &version));
-  NAPI_CALL(env, napi_create_number(env, version, &result));
+  NAPI_CALL(env, napi_create_uint32(env, version, &result));
   return result;
 }
 
diff --git a/test/addons-napi/test_number/test_number.c b/test/addons-napi/test_number/test_number.c
index 1054741d2de369..6b28afe18ff9e8 100644
--- a/test/addons-napi/test_number/test_number.c
+++ b/test/addons-napi/test_number/test_number.c
@@ -18,7 +18,7 @@ napi_value Test(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_get_value_double(env, args[0], &input));
 
   napi_value output;
-  NAPI_CALL(env, napi_create_number(env, input, &output));
+  NAPI_CALL(env, napi_create_double(env, input, &output));
 
   return output;
 }
@@ -40,7 +40,7 @@ napi_value TestInt32Truncation(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_get_value_int32(env, args[0], &input));
 
   napi_value output;
-  NAPI_CALL(env, napi_create_number(env, input, &output));
+  NAPI_CALL(env, napi_create_int32(env, input, &output));
 
   return output;
 }
diff --git a/test/addons-napi/test_object/test_object.c b/test/addons-napi/test_object/test_object.c
index 663e561a35b197..88ac79c170f5ea 100644
--- a/test/addons-napi/test_object/test_object.c
+++ b/test/addons-napi/test_object/test_object.c
@@ -144,7 +144,7 @@ napi_value New(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_create_object(env, &ret));
 
   napi_value num;
-  NAPI_CALL(env, napi_create_number(env, 987654321, &num));
+  NAPI_CALL(env, napi_create_int32(env, 987654321, &num));
 
   NAPI_CALL(env, napi_set_named_property(env, ret, "test_number", num));
 
@@ -187,7 +187,7 @@ napi_value Inflate(napi_env env, napi_callback_info info) {
 
     double double_val;
     NAPI_CALL(env, napi_get_value_double(env, value, &double_val));
-    NAPI_CALL(env, napi_create_number(env, double_val + 1, &value));
+    NAPI_CALL(env, napi_create_double(env, double_val + 1, &value));
     NAPI_CALL(env, napi_set_property(env, obj, property_str, value));
   }
 
diff --git a/test/addons-napi/test_properties/test_properties.c b/test/addons-napi/test_properties/test_properties.c
index 3053fda4864e8f..3f4f0a6bcbba96 100644
--- a/test/addons-napi/test_properties/test_properties.c
+++ b/test/addons-napi/test_properties/test_properties.c
@@ -10,7 +10,7 @@ napi_value GetValue(napi_env env, napi_callback_info info) {
   NAPI_ASSERT(env, argc == 0, "Wrong number of arguments");
 
   napi_value number;
-  NAPI_CALL(env, napi_create_number(env, value_, &number));
+  NAPI_CALL(env, napi_create_double(env, value_, &number));
 
   return number;
 }
@@ -61,7 +61,7 @@ napi_value HasNamedProperty(napi_env env, napi_callback_info info) {
 
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_value number;
-  NAPI_CALL_RETURN_VOID(env, napi_create_number(env, value_, &number));
+  NAPI_CALL_RETURN_VOID(env, napi_create_double(env, value_, &number));
 
   napi_value name_value;
   NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env,
diff --git a/test/addons-napi/test_reference/test_reference.c b/test/addons-napi/test_reference/test_reference.c
index 0d3925ee5d04bc..b16e10d70361b5 100644
--- a/test/addons-napi/test_reference/test_reference.c
+++ b/test/addons-napi/test_reference/test_reference.c
@@ -8,7 +8,7 @@ static napi_ref test_reference = NULL;
 
 napi_value GetFinalizeCount(napi_env env, napi_callback_info info) {
   napi_value result;
-  NAPI_CALL(env, napi_create_number(env, finalize_count, &result));
+  NAPI_CALL(env, napi_create_int32(env, finalize_count, &result));
   return result;
 }
 
@@ -107,7 +107,7 @@ napi_value IncrementRefcount(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_reference_ref(env, test_reference, &refcount));
 
   napi_value result;
-  NAPI_CALL(env, napi_create_number(env, refcount, &result));
+  NAPI_CALL(env, napi_create_uint32(env, refcount, &result));
   return result;
 }
 
@@ -119,7 +119,7 @@ napi_value DecrementRefcount(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_reference_unref(env, test_reference, &refcount));
 
   napi_value result;
-  NAPI_CALL(env, napi_create_number(env, refcount, &result));
+  NAPI_CALL(env, napi_create_uint32(env, refcount, &result));
   return result;
 }
 
diff --git a/test/addons-napi/test_string/test_string.c b/test/addons-napi/test_string/test_string.c
index 5cd6d413a679fb..ec80e2c7b57fa8 100644
--- a/test/addons-napi/test_string/test_string.c
+++ b/test/addons-napi/test_string/test_string.c
@@ -174,7 +174,7 @@ napi_value Utf16Length(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_get_value_string_utf16(env, args[0], NULL, 0, &length));
 
   napi_value output;
-  NAPI_CALL(env, napi_create_number(env, (double)length, &output));
+  NAPI_CALL(env, napi_create_uint32(env, (uint32_t)length, &output));
 
   return output;
 }
@@ -196,7 +196,7 @@ napi_value Utf8Length(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_get_value_string_utf8(env, args[0], NULL, 0, &length));
 
   napi_value output;
-  NAPI_CALL(env, napi_create_number(env, (double)length, &output));
+  NAPI_CALL(env, napi_create_uint32(env, (uint32_t)length, &output));
 
   return output;
 }

From 11427caf9fdbd9573cd461724372c5250eaa8b2b Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Tue, 8 Aug 2017 19:09:28 +0200
Subject: [PATCH 091/183] n-api: add napi_get_node_version
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add `napi_get_node_version`, to help with feature-detecting
Node.js as an environment.

PR-URL: https://github.com/nodejs/node/pull/14696
Reviewed-By: Kyle Farnung <kfarnung@microsoft.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
---
 doc/api/n-api.md                             | 31 ++++++++++++++++++++
 src/node.cc                                  |  3 +-
 src/node_api.cc                              | 14 +++++++++
 src/node_api.h                               |  4 +++
 src/node_api_types.h                         |  7 +++++
 src/node_version.h                           |  4 +++
 test/addons-napi/test_general/test.js        |  5 ++++
 test/addons-napi/test_general/test_general.c | 20 +++++++++++++
 8 files changed, 87 insertions(+), 1 deletion(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 5b7c97d15af6a5..0009a279309daf 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -3285,6 +3285,35 @@ callback invocation, even if it has been successfully cancelled.
 
 ## Version Management
 
+### napi_get_node_version
+<!-- YAML
+added: REPLACEME
+-->
+
+```C
+typedef struct {
+  uint32_t major;
+  uint32_t minor;
+  uint32_t patch;
+  const char* release;
+} napi_node_version;
+
+NAPI_EXTERN
+napi_status napi_get_node_version(napi_env env,
+                                  const napi_node_version** version);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[out] version`: A pointer to version information for Node itself.
+
+Returns `napi_ok` if the API succeeded.
+
+This function fills the `version` struct with the major, minor and patch version
+of Node that is currently running, and the `release` field with the
+value of [`process.release.name`][`process.release`].
+
+The returned buffer is statically allocated and does not need to be freed.
+
 ### napi_get_version
 <!-- YAML
 added: REPLACEME
@@ -3369,3 +3398,5 @@ support it:
 [`napi_throw_type_error`]: #n_api_napi_throw_type_error
 [`napi_unwrap`]: #n_api_napi_unwrap
 [`napi_wrap`]: #n_api_napi_wrap
+
+[`process.release`]: process.html#process_process_release
diff --git a/src/node.cc b/src/node.cc
index 46ca0cd9ec5020..454342cd52224b 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -3254,7 +3254,8 @@ void SetupProcessObject(Environment* env,
   // process.release
   Local<Object> release = Object::New(env->isolate());
   READONLY_PROPERTY(process, "release", release);
-  READONLY_PROPERTY(release, "name", OneByteString(env->isolate(), "node"));
+  READONLY_PROPERTY(release, "name",
+                    OneByteString(env->isolate(), NODE_RELEASE));
 
 #if NODE_VERSION_IS_LTS
   READONLY_PROPERTY(release, "lts",
diff --git a/src/node_api.cc b/src/node_api.cc
index 948f6afef55291..2caa85aee5fc2c 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -3122,6 +3122,20 @@ napi_status napi_get_version(napi_env env, uint32_t* result) {
   return napi_clear_last_error(env);
 }
 
+napi_status napi_get_node_version(napi_env env,
+                                  const napi_node_version** result) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
+  static const napi_node_version version = {
+    NODE_MAJOR_VERSION,
+    NODE_MINOR_VERSION,
+    NODE_PATCH_VERSION,
+    NODE_RELEASE
+  };
+  *result = &version;
+  return napi_clear_last_error(env);
+}
+
 namespace uvimpl {
 
 static napi_status ConvertUVErrorCode(int code) {
diff --git a/src/node_api.h b/src/node_api.h
index cf4128be210fe7..0cf0ba046997d3 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -536,6 +536,10 @@ NAPI_EXTERN napi_status napi_cancel_async_work(napi_env env,
 // version management
 NAPI_EXTERN napi_status napi_get_version(napi_env env, uint32_t* result);
 
+NAPI_EXTERN
+napi_status napi_get_node_version(napi_env env,
+                                  const napi_node_version** version);
+
 EXTERN_C_END
 
 #endif  // SRC_NODE_API_H_
diff --git a/src/node_api_types.h b/src/node_api_types.h
index 43102c519c03f9..0bdc377c8fc6a0 100644
--- a/src/node_api_types.h
+++ b/src/node_api_types.h
@@ -102,4 +102,11 @@ typedef struct {
   napi_status error_code;
 } napi_extended_error_info;
 
+typedef struct {
+  uint32_t major;
+  uint32_t minor;
+  uint32_t patch;
+  const char* release;
+} napi_node_version;
+
 #endif  // SRC_NODE_API_TYPES_H_
diff --git a/src/node_version.h b/src/node_version.h
index a6b675108a55df..629a59ec949b0d 100644
--- a/src/node_version.h
+++ b/src/node_version.h
@@ -15,6 +15,10 @@
 #define NODE_STRINGIFY_HELPER(n) #n
 #endif
 
+#ifndef NODE_RELEASE
+#define NODE_RELEASE "node"
+#endif
+
 #ifndef NODE_TAG
 # if NODE_VERSION_IS_RELEASE
 #  define NODE_TAG ""
diff --git a/test/addons-napi/test_general/test.js b/test/addons-napi/test_general/test.js
index 36610af8c8c15f..5dfdf6e8539c5a 100644
--- a/test/addons-napi/test_general/test.js
+++ b/test/addons-napi/test_general/test.js
@@ -35,6 +35,11 @@ assert.ok(test_general.testGetPrototype(baseObject) !==
 // expected version is currently 1
 assert.strictEqual(test_general.testGetVersion(), 1);
 
+const [ major, minor, patch, release ] = test_general.testGetNodeVersion();
+assert.strictEqual(process.version.split('-')[0],
+                   `v${major}.${minor}.${patch}`);
+assert.strictEqual(release, process.release.name);
+
 [
   123,
   'test string',
diff --git a/test/addons-napi/test_general/test_general.c b/test/addons-napi/test_general/test_general.c
index 858611939474b2..da347bd68bcc9a 100644
--- a/test/addons-napi/test_general/test_general.c
+++ b/test/addons-napi/test_general/test_general.c
@@ -33,6 +33,25 @@ napi_value testGetVersion(napi_env env, napi_callback_info info) {
   return result;
 }
 
+napi_value testGetNodeVersion(napi_env env, napi_callback_info info) {
+  const napi_node_version* node_version;
+  napi_value result, major, minor, patch, release;
+  NAPI_CALL(env, napi_get_node_version(env, &node_version));
+  NAPI_CALL(env, napi_create_uint32(env, node_version->major, &major));
+  NAPI_CALL(env, napi_create_uint32(env, node_version->minor, &minor));
+  NAPI_CALL(env, napi_create_uint32(env, node_version->patch, &patch));
+  NAPI_CALL(env, napi_create_string_utf8(env,
+                                         node_version->release,
+                                         (size_t)-1,
+                                         &release));
+  NAPI_CALL(env, napi_create_array_with_length(env, 4, &result));
+  NAPI_CALL(env, napi_set_element(env, result, 0, major));
+  NAPI_CALL(env, napi_set_element(env, result, 1, minor));
+  NAPI_CALL(env, napi_set_element(env, result, 2, patch));
+  NAPI_CALL(env, napi_set_element(env, result, 3, release));
+  return result;
+}
+
 napi_value doInstanceOf(napi_env env, napi_callback_info info) {
   size_t argc = 2;
   napi_value args[2];
@@ -142,6 +161,7 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("testStrictEquals", testStrictEquals),
     DECLARE_NAPI_PROPERTY("testGetPrototype", testGetPrototype),
     DECLARE_NAPI_PROPERTY("testGetVersion", testGetVersion),
+    DECLARE_NAPI_PROPERTY("testGetNodeVersion", testGetNodeVersion),
     DECLARE_NAPI_PROPERTY("doInstanceOf", doInstanceOf),
     DECLARE_NAPI_PROPERTY("getUndefined", getUndefined),
     DECLARE_NAPI_PROPERTY("getNull", getNull),

From 7ca8b1dfa9060c08ced44a17073f436200fddad4 Mon Sep 17 00:00:00 2001
From: Vincent Xue <vincent.xue@servicemax.com>
Date: Mon, 17 Jul 2017 11:58:38 +0800
Subject: [PATCH 092/183] test: use regular expressions in throw assertions
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Test errors thrown in addons-napi/test_constructor more specifically.

PR-URL: https://github.com/nodejs/node/pull/14318
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
---
 test/addons-napi/test_constructor/test.js | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/test/addons-napi/test_constructor/test.js b/test/addons-napi/test_constructor/test.js
index 75c7b3678306e4..616ba6c2a2927e 100644
--- a/test/addons-napi/test_constructor/test.js
+++ b/test/addons-napi/test_constructor/test.js
@@ -13,7 +13,8 @@ assert.strictEqual(test_object.readwriteValue, 1);
 test_object.readwriteValue = 2;
 assert.strictEqual(test_object.readwriteValue, 2);
 
-assert.throws(() => { test_object.readonlyValue = 3; }, TypeError);
+assert.throws(() => { test_object.readonlyValue = 3; },
+              /^TypeError: Cannot assign to read only property 'readonlyValue' of object '#<MyObject>'$/);
 
 assert.ok(test_object.hiddenValue);
 
@@ -35,11 +36,13 @@ assert.ok(!propertyNames.includes('readonlyAccessor2'));
 test_object.readwriteAccessor1 = 1;
 assert.strictEqual(test_object.readwriteAccessor1, 1);
 assert.strictEqual(test_object.readonlyAccessor1, 1);
-assert.throws(() => { test_object.readonlyAccessor1 = 3; }, TypeError);
+assert.throws(() => { test_object.readonlyAccessor1 = 3; },
+              /^TypeError: Cannot assign to read only property 'readonlyAccessor1' of object '#<MyObject>'$/);
 test_object.readwriteAccessor2 = 2;
 assert.strictEqual(test_object.readwriteAccessor2, 2);
 assert.strictEqual(test_object.readonlyAccessor2, 2);
-assert.throws(() => { test_object.readonlyAccessor2 = 3; }, TypeError);
+assert.throws(() => { test_object.readonlyAccessor2 = 3; },
+              /^TypeError: Cannot assign to read only property 'readonlyAccessor2' of object '#<MyObject>'$/);
 
 // validate that static properties are on the class as opposed
 // to the instance

From ca8eaa2ca8706a8f4cdfb4e8089da6686550849e Mon Sep 17 00:00:00 2001
From: Refael Ackermann <refack@gmail.com>
Date: Wed, 9 Aug 2017 00:16:41 -0400
Subject: [PATCH 093/183] doc: delint

PR-URL: https://github.com/nodejs/node/pull/14707
Refs: https://github.com/nodejs/node/pull/12756
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Daijiro Wachi <daijiro.wachi@gmail.com>
Reviewed-By: Sakthipriyan Vairamani <thechargingvolcano@gmail.com>
---
 doc/api/n-api.md | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 0009a279309daf..43b5bddb5f634b 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -342,7 +342,7 @@ to be added to the error object.  If the optional parameter is NULL
 then no code will be associated with the error. If a code is provided,
 the name associated with the error is also updated to be:
 
-```
+```text
 originalName [code]
 ```
 
@@ -350,7 +350,7 @@ where originalName is the original name associated with the error
 and code is the code that was provided.  For example if the code
 is 'ERR_ERROR_1' and a TypeError is being created the name will be:
 
-```
+```text
 TypeError [ERR_ERROR_1]
 ```
 
@@ -3342,6 +3342,8 @@ support it:
 * If the function is not available, provide an alternate implementation
   that does not use the function.
 
+<!-- it's very convenient to have all the anchors indexed -->
+<!--lint disable no-unused-definitions remark-lint-->
 [Asynchronous Operations]: #n_api_asynchronous_operations
 [Basic N-API Data Types]: #n_api_basic_n_api_data_types
 [ECMAScript Language Specification]: https://tc39.github.io/ecma262/

From b0abcbf37487573b604460574281efd0f863d1bf Mon Sep 17 00:00:00 2001
From: Kyle Farnung <kfarnung@microsoft.com>
Date: Mon, 7 Aug 2017 14:07:19 -0700
Subject: [PATCH 094/183] doc: added napi_get_value_string_latin1

* Reordered string functions alphabetically
* Fixed a typo in napi_get_value_string_utf8

PR-URL: https://github.com/nodejs/node/pull/14678
Fixes: https://github.com/nodejs/node/issues/14397
Refs: https://github.com/nodejs/node/issues/14256
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
---
 doc/api/n-api.md | 73 +++++++++++++++++++++++++++++++++---------------
 1 file changed, 50 insertions(+), 23 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 43b5bddb5f634b..c26a1222e19be2 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -1462,51 +1462,51 @@ The JavaScript Number type is described in
 [Section 6.1.6](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type)
 of the ECMAScript Language Specification.
 
-#### *napi_create_string_utf16*
+#### *napi_create_string_latin1*
 <!-- YAML
 added: v8.0.0
 -->
 ```C
-napi_status napi_create_string_utf16(napi_env env,
-                                     const char16_t* str,
-                                     size_t length,
-                                     napi_value* result)
+NAPI_EXTERN napi_status napi_create_string_latin1(napi_env env,
+                                                  const char* str,
+                                                  size_t length,
+                                                  napi_value* result);
 ```
 
 - `[in] env`: The environment that the API is invoked under.
-- `[in] str`: Character buffer representing a UTF16-LE-encoded string.
-- `[in] length`: The length of the string in two-byte code units, or -1 if
-it is null-terminated.
+- `[in] str`: Character buffer representing a ISO-8859-1-encoded string.
+- `[in] length`: The length of the string in bytes, or -1 if it is
+null-terminated.
 - `[out] result`: A `napi_value` representing a JavaScript String.
 
 Returns `napi_ok` if the API succeeded.
 
-This API creates a JavaScript String object from a UTF16-LE-encoded C string
+This API creates a JavaScript String object from a ISO-8859-1-encoded C string.
 
 The JavaScript String type is described in
 [Section 6.1.4](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type)
 of the ECMAScript Language Specification.
 
-#### *napi_create_string_latin1*
+#### *napi_create_string_utf16*
 <!-- YAML
 added: v8.0.0
 -->
 ```C
-NAPI_EXTERN napi_status napi_create_string_latin1(napi_env env,
-                                                  const char* str,
-                                                  size_t length,
-                                                  napi_value* result);
+napi_status napi_create_string_utf16(napi_env env,
+                                     const char16_t* str,
+                                     size_t length,
+                                     napi_value* result)
 ```
 
 - `[in] env`: The environment that the API is invoked under.
-- `[in] str`: Character buffer representing a latin1-encoded string.
-- `[in] length`: The length of the string in bytes, or -1 if it is
-null-terminated.
+- `[in] str`: Character buffer representing a UTF16-LE-encoded string.
+- `[in] length`: The length of the string in two-byte code units, or -1 if
+it is null-terminated.
 - `[out] result`: A `napi_value` representing a JavaScript String.
 
 Returns `napi_ok` if the API succeeded.
 
-This API creates a JavaScript String object from a latin1-encoded C string.
+This API creates a JavaScript String object from a UTF16-LE-encoded C string
 
 The JavaScript String type is described in
 [Section 6.1.4](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type)
@@ -1795,6 +1795,33 @@ is passed in it returns `napi_number_expected`.
 This API returns the C int64 primitive equivalent of the given
 JavaScript Number
 
+#### *napi_get_value_string_latin1*
+<!-- YAML
+added: v8.0.0
+-->
+```C
+NAPI_EXTERN napi_status napi_get_value_string_latin1(napi_env env,
+                                                     napi_value value,
+                                                     char* buf,
+                                                     size_t bufsize,
+                                                     size_t* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] value`: `napi_value` representing JavaScript string.
+- `[in] buf`: Buffer to write the ISO-8859-1-encoded string into. If NULL is
+passed in, the length of the string (in bytes) is returned.
+- `[in] bufsize`: Size of the destination buffer.
+- `[out] result`: Number of bytes copied into the buffer including the null
+terminator. If the buffer size is insufficient, the string will be truncated
+including a null terminator.
+
+Returns `napi_ok` if the API succeeded. If a non-String `napi_value`
+is passed in it returns `napi_string_expected`.
+
+This API returns the ISO-8859-1-encoded string corresponding the value passed
+in.
+
 #### *napi_get_value_string_utf8*
 <!-- YAML
 added: v8.0.0
@@ -1810,14 +1837,14 @@ napi_status napi_get_value_string_utf8(napi_env env,
 - `[in] env`: The environment that the API is invoked under.
 - `[in] value`: `napi_value` representing JavaScript string.
 - `[in] buf`: Buffer to write the UTF8-encoded string into. If NULL is passed
- in, the length of the string (in bytes) is returned.
+in, the length of the string (in bytes) is returned.
 - `[in] bufsize`: Size of the destination buffer.
-- `[out] result`: Number of bytes copied into the buffer including the null.
+- `[out] result`: Number of bytes copied into the buffer including the null
 terminator. If the buffer size is insufficient, the string will be truncated
 including a null terminator.
 
-Returns `napi_ok` if the API succeeded. Ifa non-String `napi_value`
-x is passed in it returns `napi_string_expected`.
+Returns `napi_ok` if the API succeeded. If a non-String `napi_value`
+is passed in it returns `napi_string_expected`.
 
 This API returns the UTF8-encoded string corresponding the value passed in.
 
@@ -1839,7 +1866,7 @@ napi_status napi_get_value_string_utf16(napi_env env,
 passed in, the length of the string (in 2-byte code units) is returned.
 - `[in] bufsize`: Size of the destination buffer.
 - `[out] result`: Number of 2-byte code units copied into the buffer including
-the null terminateor. If the buffer size is insufficient, the string will be
+the null terminator. If the buffer size is insufficient, the string will be
 truncated including a null terminator.
 
 Returns `napi_ok` if the API succeeded. If a non-String `napi_value`

From f3a8d0ad96c2f7e8b70a4bb6606e08a930747ba0 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Thu, 27 Jul 2017 20:59:29 +0300
Subject: [PATCH 095/183] n-api: add ability to remove a wrapping

Calling napi_wrap() twice on the same object has the result of returning
napi_invalid_arg on the second call. However, sometimes it is necessary
to replace the native pointer associated with a given object. This new
API allows one to remove an existing pointer, returning the object to
its pristine, non-wrapped state.

PR-URL: https://github.com/nodejs/node/pull/14658
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Fixes: https://github.com/nodejs/abi-stable-node/issues/266
---
 doc/api/n-api.md                             | 30 ++++++-
 src/node_api.cc                              | 87 +++++++++++++++-----
 src/node_api.h                               |  3 +
 test/addons-napi/test_general/test.js        | 30 ++++++-
 test/addons-napi/test_general/test_general.c | 53 ++++++++++++
 5 files changed, 178 insertions(+), 25 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index c26a1222e19be2..be06a5ab3bed7a 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -3152,7 +3152,9 @@ Afterward, additional manipulation of the wrapper's prototype chain may cause
 
 *Note*: Calling `napi_wrap()` a second time on an object that already has a
 native instance associated with it by virtue of a previous call to
-`napi_wrap()` will cause an error to be returned.
+`napi_wrap()` will cause an error to be returned. If you wish to associate
+another native instance with the given object, call `napi_remove_wrap()` on it
+first.
 
 ### *napi_unwrap*
 <!-- YAML
@@ -3165,8 +3167,8 @@ napi_status napi_unwrap(napi_env env,
 ```
 
  - `[in] env`: The environment that the API is invoked under.
- - `[in] js_object`: The object associated with the C++ class instance.
- - `[out] result`: Pointer to the wrapped C++ class instance.
+ - `[in] js_object`: The object associated with the native instance.
+ - `[out] result`: Pointer to the wrapped native instance.
 
 Returns `napi_ok` if the API succeeded.
 
@@ -3179,6 +3181,28 @@ method or accessor, then the `this` argument to the callback is the wrapper
 object; the wrapped C++ instance that is the target of the call can be obtained
 then by calling `napi_unwrap()` on the wrapper object.
 
+### *napi_remove_wrap*
+<!-- YAML
+added: REPLACEME
+-->
+```C
+napi_status napi_remove_wrap(napi_env env,
+                             napi_value js_object,
+                             void** result);
+```
+
+ - `[in] env`: The environment that the API is invoked under.
+ - `[in] js_object`: The object associated with the native instance.
+ - `[out] result`: Pointer to the wrapped native instance.
+
+Returns `napi_ok` if the API succeeded.
+
+Retrieves a native instance that was previously wrapped in the JavaScript
+object `js_object` using `napi_wrap()` and removes the wrapping, thereby
+restoring the JavaScript object's prototype chain. If a finalize callback was
+associated with the wrapping, it will no longer be called when the JavaScript
+object becomes garbage-collected.
+
 ## Asynchronous Operations
 
 Addon modules often need to leverage async helpers from libuv as part of their
diff --git a/src/node_api.cc b/src/node_api.cc
index 2caa85aee5fc2c..db66ea0bab4550 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -679,6 +679,8 @@ v8::Local<v8::Object> CreateAccessorCallbackData(napi_env env,
   return cbdata;
 }
 
+int kWrapperFields = 3;
+
 // Pointer used to identify items wrapped by N-API. Used by FindWrapper and
 // napi_wrap().
 const char napi_wrap_name[] = "N-API Wrapper";
@@ -687,7 +689,8 @@ const char napi_wrap_name[] = "N-API Wrapper";
 // wrapper would be the first in the chain, but it is OK for other objects to
 // be inserted in the prototype chain.
 bool FindWrapper(v8::Local<v8::Object> obj,
-                 v8::Local<v8::Object>* result = nullptr) {
+                 v8::Local<v8::Object>* result = nullptr,
+                 v8::Local<v8::Object>* parent = nullptr) {
   v8::Local<v8::Object> wrapper = obj;
 
   do {
@@ -695,8 +698,11 @@ bool FindWrapper(v8::Local<v8::Object> obj,
     if (proto.IsEmpty() || !proto->IsObject()) {
       return false;
     }
+    if (parent != nullptr) {
+      *parent = wrapper;
+    }
     wrapper = proto.As<v8::Object>();
-    if (wrapper->InternalFieldCount() == 2) {
+    if (wrapper->InternalFieldCount() == kWrapperFields) {
       v8::Local<v8::Value> external = wrapper->GetInternalField(1);
       if (external->IsExternal() &&
           external.As<v8::External>()->Value() == v8impl::napi_wrap_name) {
@@ -750,6 +756,29 @@ napi_env GetEnv(v8::Local<v8::Context> context) {
   return result;
 }
 
+napi_status Unwrap(napi_env env,
+                   napi_value js_object,
+                   void** result,
+                   v8::Local<v8::Object>* wrapper,
+                   v8::Local<v8::Object>* parent = nullptr) {
+  CHECK_ARG(env, js_object);
+  CHECK_ARG(env, result);
+
+  v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(js_object);
+  RETURN_STATUS_IF_FALSE(env, value->IsObject(), napi_invalid_arg);
+  v8::Local<v8::Object> obj = value.As<v8::Object>();
+
+  RETURN_STATUS_IF_FALSE(
+    env, v8impl::FindWrapper(obj, wrapper, parent), napi_invalid_arg);
+
+  v8::Local<v8::Value> unwrappedValue = (*wrapper)->GetInternalField(0);
+  RETURN_STATUS_IF_FALSE(env, unwrappedValue->IsExternal(), napi_invalid_arg);
+
+  *result = unwrappedValue.As<v8::External>()->Value();
+
+  return napi_ok;
+}
+
 }  // end of namespace v8impl
 
 // Intercepts the Node-V8 module registration callback. Converts parameters
@@ -2269,62 +2298,78 @@ napi_status napi_wrap(napi_env env,
   // Create a wrapper object with an internal field to hold the wrapped pointer
   // and a second internal field to identify the owner as N-API.
   v8::Local<v8::ObjectTemplate> wrapper_template;
-  ENV_OBJECT_TEMPLATE(env, wrap, wrapper_template, 2);
+  ENV_OBJECT_TEMPLATE(env, wrap, wrapper_template, v8impl::kWrapperFields);
 
   auto maybe_object = wrapper_template->NewInstance(context);
   CHECK_MAYBE_EMPTY(env, maybe_object, napi_generic_failure);
-
   v8::Local<v8::Object> wrapper = maybe_object.ToLocalChecked();
-  wrapper->SetInternalField(1, v8::External::New(isolate,
-    reinterpret_cast<void*>(const_cast<char*>(v8impl::napi_wrap_name))));
 
   // Store the pointer as an external in the wrapper.
   wrapper->SetInternalField(0, v8::External::New(isolate, native_object));
+  wrapper->SetInternalField(1, v8::External::New(isolate,
+    reinterpret_cast<void*>(const_cast<char*>(v8impl::napi_wrap_name))));
 
   // Insert the wrapper into the object's prototype chain.
   v8::Local<v8::Value> proto = obj->GetPrototype();
   CHECK(wrapper->SetPrototype(context, proto).FromJust());
   CHECK(obj->SetPrototype(context, wrapper).FromJust());
 
+  v8impl::Reference* reference = nullptr;
   if (result != nullptr) {
     // The returned reference should be deleted via napi_delete_reference()
     // ONLY in response to the finalize callback invocation. (If it is deleted
     // before then, then the finalize callback will never be invoked.)
     // Therefore a finalize callback is required when returning a reference.
     CHECK_ARG(env, finalize_cb);
-    v8impl::Reference* reference = v8impl::Reference::New(
+    reference = v8impl::Reference::New(
         env, obj, 0, false, finalize_cb, native_object, finalize_hint);
     *result = reinterpret_cast<napi_ref>(reference);
   } else if (finalize_cb != nullptr) {
     // Create a self-deleting reference just for the finalize callback.
-    v8impl::Reference::New(
+    reference = v8impl::Reference::New(
         env, obj, 0, true, finalize_cb, native_object, finalize_hint);
   }
 
+  if (reference != nullptr) {
+    wrapper->SetInternalField(2, v8::External::New(isolate, reference));
+  }
+
   return GET_RETURN_STATUS(env);
 }
 
-napi_status napi_unwrap(napi_env env, napi_value js_object, void** result) {
+napi_status napi_unwrap(napi_env env, napi_value obj, void** result) {
   // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
   // JS exceptions.
   CHECK_ENV(env);
-  CHECK_ARG(env, js_object);
-  CHECK_ARG(env, result);
-
-  v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(js_object);
-  RETURN_STATUS_IF_FALSE(env, value->IsObject(), napi_invalid_arg);
-  v8::Local<v8::Object> obj = value.As<v8::Object>();
+  v8::Local<v8::Object> wrapper;
+  return napi_set_last_error(env, v8impl::Unwrap(env, obj, result, &wrapper));
+}
 
+napi_status napi_remove_wrap(napi_env env, napi_value obj, void** result) {
+  NAPI_PREAMBLE(env);
   v8::Local<v8::Object> wrapper;
-  RETURN_STATUS_IF_FALSE(
-    env, v8impl::FindWrapper(obj, &wrapper), napi_invalid_arg);
+  v8::Local<v8::Object> parent;
+  napi_status status = v8impl::Unwrap(env, obj, result, &wrapper, &parent);
+  if (status != napi_ok) {
+    return napi_set_last_error(env, status);
+  }
 
-  v8::Local<v8::Value> unwrappedValue = wrapper->GetInternalField(0);
-  RETURN_STATUS_IF_FALSE(env, unwrappedValue->IsExternal(), napi_invalid_arg);
+  v8::Local<v8::Value> external = wrapper->GetInternalField(2);
+  if (external->IsExternal()) {
+    v8impl::Reference::Delete(
+        static_cast<v8impl::Reference*>(external.As<v8::External>()->Value()));
+  }
 
-  *result = unwrappedValue.As<v8::External>()->Value();
+  if (!parent.IsEmpty()) {
+    v8::Maybe<bool> maybe = parent->SetPrototype(
+        env->isolate->GetCurrentContext(), wrapper->GetPrototype());
+    CHECK_MAYBE_NOTHING(env, maybe, napi_generic_failure);
+    if (!maybe.FromMaybe(false)) {
+      return napi_set_last_error(env, napi_generic_failure);
+    }
+  }
 
-  return napi_clear_last_error(env);
+  return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_create_external(napi_env env,
diff --git a/src/node_api.h b/src/node_api.h
index 0cf0ba046997d3..e52e2016d733b9 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -362,6 +362,9 @@ NAPI_EXTERN napi_status napi_wrap(napi_env env,
 NAPI_EXTERN napi_status napi_unwrap(napi_env env,
                                     napi_value js_object,
                                     void** result);
+NAPI_EXTERN napi_status napi_remove_wrap(napi_env env,
+                                         napi_value js_object,
+                                         void** result);
 NAPI_EXTERN napi_status napi_create_external(napi_env env,
                                              void* data,
                                              napi_finalize finalize_cb,
diff --git a/test/addons-napi/test_general/test.js b/test/addons-napi/test_general/test.js
index 5dfdf6e8539c5a..10cf8b6e40132b 100644
--- a/test/addons-napi/test_general/test.js
+++ b/test/addons-napi/test_general/test.js
@@ -1,4 +1,5 @@
 'use strict';
+// Flags: --expose-gc
 
 const common = require('../../common');
 const test_general = require(`./build/${common.buildType}/test_general`);
@@ -56,10 +57,37 @@ assert.strictEqual(release, process.release.name);
 // for null
 assert.strictEqual(test_general.testNapiTypeof(null), 'null');
 
-const x = {};
+// Ensure that garbage collecting an object with a wrapped native item results
+// in the finalize callback being called.
+let w = {};
+test_general.wrap(w, []);
+w = null;
+global.gc();
+assert.strictEqual(test_general.derefItemWasCalled(), true,
+                   'deref_item() was called upon garbage collecting a ' +
+                   'wrapped object');
 
 // Assert that wrapping twice fails.
+const x = {};
 test_general.wrap(x, 25);
 assert.throws(function() {
   test_general.wrap(x, 'Blah');
 }, Error);
+
+// Ensure that wrapping, removing the wrap, and then wrapping again works.
+const y = {};
+test_general.wrap(y, -12);
+test_general.removeWrap(y);
+assert.doesNotThrow(function() {
+  test_general.wrap(y, 're-wrap!');
+}, Error, 'Wrapping twice succeeds if a remove_wrap() separates the instances');
+
+// Ensure that removing a wrap and garbage collecting does not fire the
+// finalize callback.
+let z = {};
+test_general.testFinalizeWrap(z);
+test_general.removeWrap(z);
+z = null;
+global.gc();
+assert.strictEqual(test_general.finalizeWasCalled(), false,
+                   'finalize callback was not called upon garbage collection');
diff --git a/test/addons-napi/test_general/test_general.c b/test/addons-napi/test_general/test_general.c
index da347bd68bcc9a..ecec3e014ba0b1 100644
--- a/test/addons-napi/test_general/test_general.c
+++ b/test/addons-napi/test_general/test_general.c
@@ -138,17 +138,29 @@ napi_value testNapiTypeof(napi_env env, napi_callback_info info) {
   return result;
 }
 
+static bool deref_item_called = false;
 static void deref_item(napi_env env, void* data, void* hint) {
   (void) hint;
 
+  deref_item_called = true;
   NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, (napi_ref)data));
 }
 
+napi_value deref_item_was_called(napi_env env, napi_callback_info info) {
+  napi_value it_was_called;
+
+  NAPI_CALL(env, napi_get_boolean(env, deref_item_called, &it_was_called));
+
+  return it_was_called;
+}
+
 napi_value wrap(napi_env env, napi_callback_info info) {
   size_t argc = 2;
   napi_value argv[2];
   napi_ref payload;
 
+  deref_item_called = false;
+
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
   NAPI_CALL(env, napi_create_reference(env, argv[1], 1, &payload));
   NAPI_CALL(env, napi_wrap(env, argv[0], payload, deref_item, NULL, NULL));
@@ -156,6 +168,43 @@ napi_value wrap(napi_env env, napi_callback_info info) {
   return NULL;
 }
 
+napi_value remove_wrap(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value wrapped;
+  void* data;
+
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &wrapped, NULL, NULL));
+  NAPI_CALL(env, napi_remove_wrap(env, wrapped, &data));
+  if (data != NULL) {
+    NAPI_CALL(env, napi_delete_reference(env, (napi_ref)data));
+  }
+
+  return NULL;
+}
+
+static bool finalize_called = false;
+static void test_finalize(napi_env env, void* data, void* hint) {
+  finalize_called = true;
+}
+
+napi_value test_finalize_wrap(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value js_object;
+
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &js_object, NULL, NULL));
+  NAPI_CALL(env, napi_wrap(env, js_object, NULL, test_finalize, NULL, NULL));
+
+  return NULL;
+}
+
+napi_value finalize_was_called(napi_env env, napi_callback_info info) {
+  napi_value it_was_called;
+
+  NAPI_CALL(env, napi_get_boolean(env, finalize_called, &it_was_called));
+
+  return it_was_called;
+}
+
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("testStrictEquals", testStrictEquals),
@@ -169,6 +218,10 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("testNapiErrorCleanup", testNapiErrorCleanup),
     DECLARE_NAPI_PROPERTY("testNapiTypeof", testNapiTypeof),
     DECLARE_NAPI_PROPERTY("wrap", wrap),
+    DECLARE_NAPI_PROPERTY("removeWrap", remove_wrap),
+    DECLARE_NAPI_PROPERTY("testFinalizeWrap", test_finalize_wrap),
+    DECLARE_NAPI_PROPERTY("finalizeWasCalled", finalize_was_called),
+    DECLARE_NAPI_PROPERTY("derefItemWasCalled", deref_item_was_called),
   };
 
   NAPI_CALL_RETURN_VOID(env, napi_define_properties(

From 41b7f4c6194fd624c352e16b21cd5290d7c89141 Mon Sep 17 00:00:00 2001
From: Daniel Taveras <Daniel_Taveras@condenast.com>
Date: Thu, 27 Jul 2017 21:05:01 -0400
Subject: [PATCH 096/183] doc: fix doc for napi_get_value_string_utf8

The API for napi_get_value_string_utf8() appears to have been
previously changed. This improves the doc reflect the current design.

PR-URL: https://github.com/nodejs/node/pull/14529
Fixes: https://github.com/nodejs/node/issues/14398
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 doc/api/n-api.md | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index be06a5ab3bed7a..89aa08a15198ce 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -1811,10 +1811,10 @@ NAPI_EXTERN napi_status napi_get_value_string_latin1(napi_env env,
 - `[in] value`: `napi_value` representing JavaScript string.
 - `[in] buf`: Buffer to write the ISO-8859-1-encoded string into. If NULL is
 passed in, the length of the string (in bytes) is returned.
-- `[in] bufsize`: Size of the destination buffer.
-- `[out] result`: Number of bytes copied into the buffer including the null
-terminator. If the buffer size is insufficient, the string will be truncated
-including a null terminator.
+- `[in] bufsize`: Size of the destination buffer. When this value is
+insufficient, the returned string will be truncated.
+- `[out] result`: Number of bytes copied into the buffer, excluding the null
+terminator.
 
 Returns `napi_ok` if the API succeeded. If a non-String `napi_value`
 is passed in it returns `napi_string_expected`.
@@ -1837,11 +1837,11 @@ napi_status napi_get_value_string_utf8(napi_env env,
 - `[in] env`: The environment that the API is invoked under.
 - `[in] value`: `napi_value` representing JavaScript string.
 - `[in] buf`: Buffer to write the UTF8-encoded string into. If NULL is passed
-in, the length of the string (in bytes) is returned.
-- `[in] bufsize`: Size of the destination buffer.
-- `[out] result`: Number of bytes copied into the buffer including the null
-terminator. If the buffer size is insufficient, the string will be truncated
-including a null terminator.
+ in, the length of the string (in bytes) is returned.
+- `[in] bufsize`: Size of the destination buffer. When this value is
+insufficient, the returned string will be truncated.
+- `[out] result`: Number of bytes copied into the buffer, excluding the null
+terminator.
 
 Returns `napi_ok` if the API succeeded. If a non-String `napi_value`
 is passed in it returns `napi_string_expected`.
@@ -1864,10 +1864,10 @@ napi_status napi_get_value_string_utf16(napi_env env,
 - `[in] value`: `napi_value` representing JavaScript string.
 - `[in] buf`: Buffer to write the UTF16-LE-encoded string into. If NULL is
 passed in, the length of the string (in 2-byte code units) is returned.
-- `[in] bufsize`: Size of the destination buffer.
-- `[out] result`: Number of 2-byte code units copied into the buffer including
-the null terminator. If the buffer size is insufficient, the string will be
-truncated including a null terminator.
+- `[in] bufsize`: Size of the destination buffer. When this value is
+insufficient, the returned string will be truncated.
+- `[out] result`: Number of 2-byte code units copied into the buffer, excluding the null
+terminator.
 
 Returns `napi_ok` if the API succeeded. If a non-String `napi_value`
 is passed in it returns `napi_string_expected`.

From 6ec485ad0ce86c0a37b5af471e7f02e0e8f92370 Mon Sep 17 00:00:00 2001
From: Daniil Shakir <phpinfo12345@gmail.com>
Date: Tue, 22 Aug 2017 00:36:32 +0300
Subject: [PATCH 097/183] test: remove unused parameters

PR-URL: https://github.com/nodejs/node/pull/14968
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Kunal Pathak <kunal.pathak@microsoft.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: David Cai <davidcai1993@yahoo.com>
Reviewed-By: Yuta Hiroto <hello@about-hiroppy.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/addons-napi/test_async/test.js      | 2 +-
 test/addons-napi/test_typedarray/test.js | 2 +-
 test/addons/repl-domain-abort/test.js    | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/test/addons-napi/test_async/test.js b/test/addons-napi/test_async/test.js
index eda6963743ff6f..cfd39a5b11ae2d 100644
--- a/test/addons-napi/test_async/test.js
+++ b/test/addons-napi/test_async/test.js
@@ -9,7 +9,7 @@ const testException = 'test_async_cb_exception';
 // Exception thrown from async completion callback.
 // (Tested in a spawned process because the exception is fatal.)
 if (process.argv[2] === 'child') {
-  test_async.Test(1, common.mustCall(function(err, val) {
+  test_async.Test(1, common.mustCall(function() {
     throw new Error(testException);
   }));
   return;
diff --git a/test/addons-napi/test_typedarray/test.js b/test/addons-napi/test_typedarray/test.js
index dcb7d76442f608..b81295902069b7 100644
--- a/test/addons-napi/test_typedarray/test.js
+++ b/test/addons-napi/test_typedarray/test.js
@@ -44,7 +44,7 @@ const arrayTypes = [ Int8Array, Uint8Array, Uint8ClampedArray, Int16Array,
                      Uint16Array, Int32Array, Uint32Array, Float32Array,
                      Float64Array ];
 
-arrayTypes.forEach((currentType, key) => {
+arrayTypes.forEach((currentType) => {
   const template = Reflect.construct(currentType, buffer);
   const theArray = test_typedarray.CreateTypedArray(template, buffer);
 
diff --git a/test/addons/repl-domain-abort/test.js b/test/addons/repl-domain-abort/test.js
index 8e5d8785164fb9..9b9a63abfb685c 100644
--- a/test/addons/repl-domain-abort/test.js
+++ b/test/addons/repl-domain-abort/test.js
@@ -25,7 +25,7 @@ const lines = [
 const dInput = new stream.Readable();
 const dOutput = new stream.Writable();
 
-dInput._read = function _read(size) {
+dInput._read = function _read() {
   while (lines.length > 0 && this.push(lines.shift()));
   if (lines.length === 0)
     this.push(null);

From 2bab64e3de306619ad3dd3111149e6b5abf2a8bc Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Thu, 24 Aug 2017 13:33:26 +0300
Subject: [PATCH 098/183] n-api: implement promise

Promise is implemented as a pair of objects. `napi_create_promise()`
returns both a JavaScript promise and a newly allocated "deferred" in
its out-params. The deferred is linked to the promise such that the
deferred can be passed to `napi_resolve_deferred()` or
`napi_reject_deferred()` to reject/resolve the promise.

`napi_is_promise()` can be used to check if a `napi_value` is a native
promise - that is, a promise created by the underlying engine, rather
than a pure JS implementation of a promise.

PR-URL: https://github.com/nodejs/node/pull/14365
Fixes: https://github.com/nodejs/abi-stable-node/issues/242
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
---
 doc/api/n-api.md                             | 138 +++++++++++++++++++
 src/node_api.cc                              |  78 +++++++++++
 src/node_api.h                               |  14 ++
 src/node_api_types.h                         |   1 +
 test/addons-napi/test_promise/binding.gyp    |   8 ++
 test/addons-napi/test_promise/test.js        |  60 ++++++++
 test/addons-napi/test_promise/test_promise.c |  60 ++++++++
 7 files changed, 359 insertions(+)
 create mode 100644 test/addons-napi/test_promise/binding.gyp
 create mode 100644 test/addons-napi/test_promise/test.js
 create mode 100644 test/addons-napi/test_promise/test_promise.c

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 89aa08a15198ce..12aad7583f6d93 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -42,6 +42,7 @@ The documentation for N-API is structured as follows:
 * [Working with JavaScript Functions][]
 * [Object Wrap][]
 * [Asynchronous Operations][]
+* [Promises][]
 
 The N-API is a C API that ensures ABI stability across Node.js versions
 and different compiler levels. However, we also understand that a C++
@@ -3395,6 +3396,142 @@ support it:
 
 <!-- it's very convenient to have all the anchors indexed -->
 <!--lint disable no-unused-definitions remark-lint-->
+## Promises
+
+N-API provides facilities for creating `Promise` objects as described in
+[Section 25.4][] of the ECMA specification. It implements promises as a pair of
+objects. When a promise is created by `napi_create_promise()`, a "deferred"
+object is created and returned alongside the `Promise`. The deferred object is
+bound to the created `Promise` and is the only means to resolve or reject the
+`Promise` using `napi_resolve_deferred()` or `napi_reject_deferred()`. The
+deferred object that is created by `napi_create_promise()` is freed by
+`napi_resolve_deferred()` or `napi_reject_deferred()`. The `Promise` object may
+be returned to JavaScript where it can be used in the usual fashion.
+
+For example, to create a promise and pass it to an asynchronous worker:
+```c
+napi_deferred deferred;
+napi_value promise;
+napi_status status;
+
+// Create the promise.
+status = napi_create_promise(env, &deferred, &promise);
+if (status != napi_ok) return NULL;
+
+// Pass the deferred to a function that performs an asynchronous action.
+do_something_asynchronous(deferred);
+
+// Return the promise to JS
+return promise;
+```
+
+The above function `do_something_asynchronous()` would perform its asynchronous
+action and then it would resolve or reject the deferred, thereby concluding the
+promise and freeing the deferred:
+```c
+napi_deferred deferred;
+napi_value undefined;
+napi_status status;
+
+// Create a value with which to conclude the deferred.
+status = napi_get_undefined(env, &undefined);
+if (status != napi_ok) return NULL;
+
+// Resolve or reject the promise associated with the deferred depending on
+// whether the asynchronous action succeeded.
+if (asynchronous_action_succeeded) {
+  status = napi_resolve_deferred(env, deferred, undefined);
+} else {
+  status = napi_reject_deferred(env, deferred, undefined);
+}
+if (status != napi_ok) return NULL;
+
+// At this point the deferred has been freed, so we should assign NULL to it.
+deferred = NULL;
+```
+
+### napi_create_promise
+<!-- YAML
+added: REPLACEME
+-->
+```C
+NAPI_EXTERN napi_status napi_create_promise(napi_env env,
+                                            napi_deferred* deferred,
+                                            napi_value* promise);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[out] deferred`: A newly created deferred object which can later be passed to
+`napi_resolve_deferred()` or `napi_reject_deferred()` to resolve resp. reject
+the associated promise.
+- `[out] promise`: The JavaScript promise associated with the deferred object.
+
+Returns `napi_ok` if the API succeeded.
+
+This API creates a deferred object and a JavaScript promise.
+
+### napi_resolve_deferred
+<!-- YAML
+added: REPLACEME
+-->
+```C
+NAPI_EXTERN napi_status napi_resolve_deferred(napi_env env,
+                                              napi_deferred deferred,
+                                              napi_value resolution);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] deferred`: The deferred object whose associated promise to resolve.
+- `[in] resolution`: The value with which to resolve the promise.
+
+This API resolves a JavaScript promise by way of the deferred object
+with which it is associated. Thus, it can only be used to resolve JavaScript
+promises for which the corresponding deferred object is available. This
+effectively means that the promise must have been created using
+`napi_create_promise()` and the deferred object returned from that call must
+have been retained in order to be passed to this API.
+
+The deferred object is freed upon successful completion.
+
+### napi_reject_deferred
+<!-- YAML
+added: REPLACEME
+-->
+```C
+NAPI_EXTERN napi_status napi_reject_deferred(napi_env env,
+                                             napi_deferred deferred,
+                                             napi_value rejection);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] deferred`: The deferred object whose associated promise to resolve.
+- `[in] rejection`: The value with which to reject the promise.
+
+This API rejects a JavaScript promise by way of the deferred object
+with which it is associated. Thus, it can only be used to reject JavaScript
+promises for which the corresponding deferred object is available. This
+effectively means that the promise must have been created using
+`napi_create_promise()` and the deferred object returned from that call must
+have been retained in order to be passed to this API.
+
+The deferred object is freed upon successful completion.
+
+### napi_is_promise
+<!-- YAML
+added: REPLACEME
+-->
+```C
+NAPI_EXTERN napi_status napi_is_promise(napi_env env,
+                                        napi_value promise,
+                                        bool* is_promise);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] promise`: The promise to examine
+- `[out] is_promise`: Flag indicating whether `promise` is a native promise
+object - that is, a promise object created by the underlying engine.
+
+[Promises]: #n_api_promises
 [Asynchronous Operations]: #n_api_asynchronous_operations
 [Basic N-API Data Types]: #n_api_basic_n_api_data_types
 [ECMAScript Language Specification]: https://tc39.github.io/ecma262/
@@ -3406,6 +3543,7 @@ support it:
 [Section 9.1.6]: https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-defineownproperty-p-desc
 [Section 12.5.5]: https://tc39.github.io/ecma262/#sec-typeof-operator
 [Section 24.3]: https://tc39.github.io/ecma262/#sec-dataview-objects
+[Section 25.4]: https://tc39.github.io/ecma262/#sec-promise-objects
 [Working with JavaScript Functions]: #n_api_working_with_javascript_functions
 [Working with JavaScript Properties]: #n_api_working_with_javascript_properties
 [Working with JavaScript Values]: #n_api_working_with_javascript_values
diff --git a/src/node_api.cc b/src/node_api.cc
index db66ea0bab4550..fd31817e4a8f71 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -223,6 +223,14 @@ V8EscapableHandleScopeFromJsEscapableHandleScope(
 static_assert(sizeof(v8::Local<v8::Value>) == sizeof(napi_value),
   "Cannot convert between v8::Local<v8::Value> and napi_value");
 
+napi_deferred JsDeferredFromV8Persistent(v8::Persistent<v8::Value>* local) {
+  return reinterpret_cast<napi_deferred>(local);
+}
+
+v8::Persistent<v8::Value>* V8PersistentFromJsDeferred(napi_deferred local) {
+  return reinterpret_cast<v8::Persistent<v8::Value>*>(local);
+}
+
 napi_value JsValueFromV8LocalValue(v8::Local<v8::Value> local) {
   return reinterpret_cast<napi_value>(*local);
 }
@@ -779,6 +787,33 @@ napi_status Unwrap(napi_env env,
   return napi_ok;
 }
 
+napi_status ConcludeDeferred(napi_env env,
+                             napi_deferred deferred,
+                             napi_value result,
+                             bool is_resolved) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(env, result);
+
+  v8::Local<v8::Context> context = env->isolate->GetCurrentContext();
+  v8::Persistent<v8::Value>* deferred_ref =
+      V8PersistentFromJsDeferred(deferred);
+  v8::Local<v8::Value> v8_deferred =
+      v8::Local<v8::Value>::New(env->isolate, *deferred_ref);
+
+  auto v8_resolver = v8::Local<v8::Promise::Resolver>::Cast(v8_deferred);
+
+  v8::Maybe<bool> success = is_resolved ?
+      v8_resolver->Resolve(context, v8impl::V8LocalValueFromJsValue(result)) :
+      v8_resolver->Reject(context, v8impl::V8LocalValueFromJsValue(result));
+
+  deferred_ref->Reset();
+  delete deferred_ref;
+
+  RETURN_STATUS_IF_FALSE(env, success.FromMaybe(false), napi_generic_failure);
+
+  return GET_RETURN_STATUS(env);
+}
+
 }  // end of namespace v8impl
 
 // Intercepts the Node-V8 module registration callback. Converts parameters
@@ -3335,3 +3370,46 @@ napi_status napi_cancel_async_work(napi_env env, napi_async_work work) {
 
   return napi_clear_last_error(env);
 }
+
+NAPI_EXTERN napi_status napi_create_promise(napi_env env,
+                                            napi_deferred* deferred,
+                                            napi_value* promise) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(env, deferred);
+  CHECK_ARG(env, promise);
+
+  auto maybe = v8::Promise::Resolver::New(env->isolate->GetCurrentContext());
+  CHECK_MAYBE_EMPTY(env, maybe, napi_generic_failure);
+
+  auto v8_resolver = maybe.ToLocalChecked();
+  auto v8_deferred = new v8::Persistent<v8::Value>();
+  v8_deferred->Reset(env->isolate, v8_resolver);
+
+  *deferred = v8impl::JsDeferredFromV8Persistent(v8_deferred);
+  *promise = v8impl::JsValueFromV8LocalValue(v8_resolver->GetPromise());
+  return GET_RETURN_STATUS(env);
+}
+
+NAPI_EXTERN napi_status napi_resolve_deferred(napi_env env,
+                                              napi_deferred deferred,
+                                              napi_value resolution) {
+  return v8impl::ConcludeDeferred(env, deferred, resolution, true);
+}
+
+NAPI_EXTERN napi_status napi_reject_deferred(napi_env env,
+                                             napi_deferred deferred,
+                                             napi_value resolution) {
+  return v8impl::ConcludeDeferred(env, deferred, resolution, false);
+}
+
+NAPI_EXTERN napi_status napi_is_promise(napi_env env,
+                                        napi_value promise,
+                                        bool* is_promise) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, promise);
+  CHECK_ARG(env, is_promise);
+
+  *is_promise = v8impl::V8LocalValueFromJsValue(promise)->IsPromise();
+
+  return napi_clear_last_error(env);
+}
diff --git a/src/node_api.h b/src/node_api.h
index e52e2016d733b9..6a4b2941879ff0 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -543,6 +543,20 @@ NAPI_EXTERN
 napi_status napi_get_node_version(napi_env env,
                                   const napi_node_version** version);
 
+// Promises
+NAPI_EXTERN napi_status napi_create_promise(napi_env env,
+                                            napi_deferred* deferred,
+                                            napi_value* promise);
+NAPI_EXTERN napi_status napi_resolve_deferred(napi_env env,
+                                              napi_deferred deferred,
+                                              napi_value resolution);
+NAPI_EXTERN napi_status napi_reject_deferred(napi_env env,
+                                             napi_deferred deferred,
+                                             napi_value rejection);
+NAPI_EXTERN napi_status napi_is_promise(napi_env env,
+                                        napi_value promise,
+                                        bool* is_promise);
+
 EXTERN_C_END
 
 #endif  // SRC_NODE_API_H_
diff --git a/src/node_api_types.h b/src/node_api_types.h
index 0bdc377c8fc6a0..ac8482bf9dcf9d 100644
--- a/src/node_api_types.h
+++ b/src/node_api_types.h
@@ -17,6 +17,7 @@ typedef struct napi_handle_scope__ *napi_handle_scope;
 typedef struct napi_escapable_handle_scope__ *napi_escapable_handle_scope;
 typedef struct napi_callback_info__ *napi_callback_info;
 typedef struct napi_async_work__ *napi_async_work;
+typedef struct napi_deferred__ *napi_deferred;
 
 typedef enum {
   napi_default = 0,
diff --git a/test/addons-napi/test_promise/binding.gyp b/test/addons-napi/test_promise/binding.gyp
new file mode 100644
index 00000000000000..bf266f93db74be
--- /dev/null
+++ b/test/addons-napi/test_promise/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_promise",
+      "sources": [ "test_promise.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_promise/test.js b/test/addons-napi/test_promise/test.js
new file mode 100644
index 00000000000000..4c2a2e5e76c9fb
--- /dev/null
+++ b/test/addons-napi/test_promise/test.js
@@ -0,0 +1,60 @@
+'use strict';
+
+const common = require('../../common');
+const test_promise = require(`./build/${common.buildType}/test_promise`);
+const assert = require('assert');
+
+let expected_result, promise;
+
+// A resolution
+expected_result = 42;
+promise = test_promise.createPromise();
+promise.then(
+  common.mustCall(function(result) {
+    assert.strictEqual(result, expected_result,
+                       'promise resolved as expected');
+  }),
+  common.mustNotCall());
+test_promise.concludeCurrentPromise(expected_result, true);
+
+// A rejection
+expected_result = 'It\'s not you, it\'s me.';
+promise = test_promise.createPromise();
+promise.then(
+  common.mustNotCall(),
+  common.mustCall(function(result) {
+    assert.strictEqual(result, expected_result,
+                       'promise rejected as expected');
+  }));
+test_promise.concludeCurrentPromise(expected_result, false);
+
+// Chaining
+promise = test_promise.createPromise();
+promise.then(
+  common.mustCall(function(result) {
+    assert.strictEqual(result, 'chained answer',
+                       'resolving with a promise chains properly');
+  }),
+  common.mustNotCall());
+test_promise.concludeCurrentPromise(Promise.resolve('chained answer'), true);
+
+assert.strictEqual(test_promise.isPromise(promise), true,
+                   'natively created promise is recognized as a promise');
+
+assert.strictEqual(test_promise.isPromise(Promise.reject(-1)), true,
+                   'Promise created with JS is recognized as a promise');
+
+assert.strictEqual(test_promise.isPromise(2.4), false,
+                   'Number is recognized as not a promise');
+
+assert.strictEqual(test_promise.isPromise('I promise!'), false,
+                   'String is recognized as not a promise');
+
+assert.strictEqual(test_promise.isPromise(undefined), false,
+                   'undefined is recognized as not a promise');
+
+assert.strictEqual(test_promise.isPromise(null), false,
+                   'null is recognized as not a promise');
+
+assert.strictEqual(test_promise.isPromise({}), false,
+                   'an object is recognized as not a promise');
diff --git a/test/addons-napi/test_promise/test_promise.c b/test/addons-napi/test_promise/test_promise.c
new file mode 100644
index 00000000000000..dc617f4592e520
--- /dev/null
+++ b/test/addons-napi/test_promise/test_promise.c
@@ -0,0 +1,60 @@
+#include <node_api.h>
+#include "../common.h"
+
+napi_deferred deferred = NULL;
+
+napi_value createPromise(napi_env env, napi_callback_info info) {
+  napi_value promise;
+
+  // We do not overwrite an existing deferred.
+  if (deferred != NULL) {
+    return NULL;
+  }
+
+  NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
+
+  return promise;
+}
+
+napi_value concludeCurrentPromise(napi_env env, napi_callback_info info) {
+  napi_value argv[2];
+  size_t argc = 2;
+  bool resolution;
+
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+  NAPI_CALL(env, napi_get_value_bool(env, argv[1], &resolution));
+  if (resolution) {
+    NAPI_CALL(env, napi_resolve_deferred(env, deferred, argv[0]));
+  } else {
+    NAPI_CALL(env, napi_reject_deferred(env, deferred, argv[0]));
+  }
+
+  deferred = NULL;
+
+  return NULL;
+}
+
+napi_value isPromise(napi_env env, napi_callback_info info) {
+  napi_value promise, result;
+  size_t argc = 1;
+  bool is_promise;
+
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &promise, NULL, NULL));
+  NAPI_CALL(env, napi_is_promise(env, promise, &is_promise));
+  NAPI_CALL(env, napi_get_boolean(env, is_promise, &result));
+
+  return result;
+}
+
+void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+  napi_property_descriptor descriptors[] = {
+    DECLARE_NAPI_PROPERTY("createPromise", createPromise),
+    DECLARE_NAPI_PROPERTY("concludeCurrentPromise", concludeCurrentPromise),
+    DECLARE_NAPI_PROPERTY("isPromise", isPromise),
+  };
+
+  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+}
+
+NAPI_MODULE(addon, Init)

From 28786e2c6b4d30ffcfe89511d635bad67a6adee5 Mon Sep 17 00:00:00 2001
From: Chris Young <chris.young@gotinder.com>
Date: Tue, 27 Jun 2017 20:56:15 -0700
Subject: [PATCH 099/183] n-api: adds function to adjust external memory

Added a wrapper around
v8::Isolate::AdjustAmountOfExternalAllocatedMemory

PR-URL: https://github.com/nodejs/node/pull/14310
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Fixes: https://github.com/nodejs/node/issues/13928
---
 doc/api/n-api.md                             | 25 ++++++++++++++++++++
 src/node_api.cc                              | 13 ++++++++++
 src/node_api.h                               |  5 ++++
 test/addons-napi/test_general/test.js        |  5 ++++
 test/addons-napi/test_general/test_general.c | 11 +++++++++
 5 files changed, 59 insertions(+)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 12aad7583f6d93..9c56e50e83f299 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -3394,6 +3394,31 @@ support it:
 * If the function is not available, provide an alternate implementation
   that does not use the function.
 
+## Memory Management
+
+### napi_adjust_external_memory
+<!-- YAML
+added: REPLACEME
+-->
+```C
+NAPI_EXTERN napi_status napi_adjust_external_memory(napi_env env,
+                                                    int64_t change_in_bytes,
+                                                    int64_t* result);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] change_in_bytes`: The change in externally allocated memory that is
+kept alive by JavaScript objects.
+- `[out] result`: The adjusted value
+
+Returns `napi_ok` if the API succeeded.
+
+This function gives V8 an indication of the amount of externally allocated
+memory that is kept alive by JavaScript objects (i.e. a JavaScript object
+that points to its own memory allocated by a native module). Registering
+externally allocated memory will trigger global garbage collections more
+often than it would otherwise.
+
 <!-- it's very convenient to have all the anchors indexed -->
 <!--lint disable no-unused-definitions remark-lint-->
 ## Promises
diff --git a/src/node_api.cc b/src/node_api.cc
index fd31817e4a8f71..a2322295fccbaa 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -3216,6 +3216,19 @@ napi_status napi_get_node_version(napi_env env,
   return napi_clear_last_error(env);
 }
 
+napi_status napi_adjust_external_memory(napi_env env,
+                                        int64_t change_in_bytes,
+                                        int64_t* adjusted_value) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, &change_in_bytes);
+  CHECK_ARG(env, adjusted_value);
+
+  *adjusted_value = env->isolate->AdjustAmountOfExternalAllocatedMemory(
+      change_in_bytes);
+
+  return napi_clear_last_error(env);
+}
+
 namespace uvimpl {
 
 static napi_status ConvertUVErrorCode(int code) {
diff --git a/src/node_api.h b/src/node_api.h
index 6a4b2941879ff0..702ddf2d9e6a0e 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -557,6 +557,11 @@ NAPI_EXTERN napi_status napi_is_promise(napi_env env,
                                         napi_value promise,
                                         bool* is_promise);
 
+// Memory management
+NAPI_EXTERN napi_status napi_adjust_external_memory(napi_env env,
+                                                    int64_t change_in_bytes,
+                                                    int64_t* adjusted_value);
+
 EXTERN_C_END
 
 #endif  // SRC_NODE_API_H_
diff --git a/test/addons-napi/test_general/test.js b/test/addons-napi/test_general/test.js
index 10cf8b6e40132b..ec59922639e949 100644
--- a/test/addons-napi/test_general/test.js
+++ b/test/addons-napi/test_general/test.js
@@ -91,3 +91,8 @@ z = null;
 global.gc();
 assert.strictEqual(test_general.finalizeWasCalled(), false,
                    'finalize callback was not called upon garbage collection');
+
+// test napi_adjust_external_memory
+const adjustedValue = test_general.testAdjustExternalMemory();
+assert.strictEqual(typeof adjustedValue, 'number');
+assert(adjustedValue > 0);
diff --git a/test/addons-napi/test_general/test_general.c b/test/addons-napi/test_general/test_general.c
index ecec3e014ba0b1..ea1f2ece0a5d30 100644
--- a/test/addons-napi/test_general/test_general.c
+++ b/test/addons-napi/test_general/test_general.c
@@ -205,6 +205,16 @@ napi_value finalize_was_called(napi_env env, napi_callback_info info) {
   return it_was_called;
 }
 
+napi_value testAdjustExternalMemory(napi_env env, napi_callback_info info) {
+  napi_value result;
+  int64_t adjustedValue;
+
+  NAPI_CALL(env, napi_adjust_external_memory(env, 1, &adjustedValue));
+  NAPI_CALL(env, napi_create_double(env, adjustedValue, &result));
+
+  return result;
+}
+
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("testStrictEquals", testStrictEquals),
@@ -222,6 +232,7 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("testFinalizeWrap", test_finalize_wrap),
     DECLARE_NAPI_PROPERTY("finalizeWasCalled", finalize_was_called),
     DECLARE_NAPI_PROPERTY("derefItemWasCalled", deref_item_was_called),
+    DECLARE_NAPI_PROPERTY("testAdjustExternalMemory", testAdjustExternalMemory)
   };
 
   NAPI_CALL_RETURN_VOID(env, napi_define_properties(

From 32504e1ab24939359776d827a520900065399161 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Wed, 6 Sep 2017 13:00:43 +0300
Subject: [PATCH 100/183] n-api: implement napi_run_script

Fixes: https://github.com/nodejs/abi-stable-node/issues/51
PR-URL: https://github.com/nodejs/node/pull/15216
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com
Reviewed-By: James M Snell <jasnell.gmail.com>
Reviewed-By: Michael Dawson <mhdawson@ca.ibm.com>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
---
 doc/api/n-api.md                             | 21 +++++++++++++++
 src/node_api.cc                              | 27 ++++++++++++++++++++
 src/node_api.h                               |  5 ++++
 test/addons-napi/test_general/testNapiRun.js | 12 +++++++++
 test/addons-napi/test_general/test_general.c | 13 ++++++++++
 5 files changed, 78 insertions(+)
 create mode 100644 test/addons-napi/test_general/testNapiRun.js

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 9c56e50e83f299..80d83612509ca1 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -43,6 +43,7 @@ The documentation for N-API is structured as follows:
 * [Object Wrap][]
 * [Asynchronous Operations][]
 * [Promises][]
+* [Script Execution][]
 
 The N-API is a C API that ensures ABI stability across Node.js versions
 and different compiler levels. However, we also understand that a C++
@@ -3556,6 +3557,25 @@ NAPI_EXTERN napi_status napi_is_promise(napi_env env,
 - `[out] is_promise`: Flag indicating whether `promise` is a native promise
 object - that is, a promise object created by the underlying engine.
 
+## Script execution
+
+N-API provides an API for executing a string containing JavaScript using the
+underlying JavaScript engine.
+
+### napi_run_script
+<!-- YAML
+added: REPLACEME
+-->
+```C
+NAPI_EXTERN napi_status napi_run_script(napi_env env,
+                                        napi_value script,
+                                        napi_value* result);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] script`: A JavaScript string containing the script to execute.
+- `[out] result`: The value resulting from having executed the script.
+
 [Promises]: #n_api_promises
 [Asynchronous Operations]: #n_api_asynchronous_operations
 [Basic N-API Data Types]: #n_api_basic_n_api_data_types
@@ -3565,6 +3585,7 @@ object - that is, a promise object created by the underlying engine.
 [Native Abstractions for Node.js]: https://github.com/nodejs/nan
 [Object Lifetime Management]: #n_api_object_lifetime_management
 [Object Wrap]: #n_api_object_wrap
+[Script Execution]: #n_api_script_execution
 [Section 9.1.6]: https://tc39.github.io/ecma262/#sec-ordinary-object-internal-methods-and-internal-slots-defineownproperty-p-desc
 [Section 12.5.5]: https://tc39.github.io/ecma262/#sec-typeof-operator
 [Section 24.3]: https://tc39.github.io/ecma262/#sec-dataview-objects
diff --git a/src/node_api.cc b/src/node_api.cc
index a2322295fccbaa..9c8e0edec94d40 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -3426,3 +3426,30 @@ NAPI_EXTERN napi_status napi_is_promise(napi_env env,
 
   return napi_clear_last_error(env);
 }
+
+NAPI_EXTERN napi_status napi_run_script(napi_env env,
+                                        napi_value script,
+                                        napi_value* result) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(env, script);
+  CHECK_ARG(env, result);
+
+  v8::Local<v8::Value> v8_script = v8impl::V8LocalValueFromJsValue(script);
+
+  if (!v8_script->IsString()) {
+    return napi_set_last_error(env, napi_string_expected);
+  }
+
+  v8::Local<v8::Context> context = env->isolate->GetCurrentContext();
+
+  auto maybe_script = v8::Script::Compile(context,
+      v8::Local<v8::String>::Cast(v8_script));
+  CHECK_MAYBE_EMPTY(env, maybe_script, napi_generic_failure);
+
+  auto script_result =
+      maybe_script.ToLocalChecked()->Run(context);
+  CHECK_MAYBE_EMPTY(env, script_result, napi_generic_failure);
+
+  *result = v8impl::JsValueFromV8LocalValue(script_result.ToLocalChecked());
+  return GET_RETURN_STATUS(env);
+}
diff --git a/src/node_api.h b/src/node_api.h
index 702ddf2d9e6a0e..807595777dd947 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -562,6 +562,11 @@ NAPI_EXTERN napi_status napi_adjust_external_memory(napi_env env,
                                                     int64_t change_in_bytes,
                                                     int64_t* adjusted_value);
 
+// Runnig a script
+NAPI_EXTERN napi_status napi_run_script(napi_env env,
+                                        napi_value script,
+                                        napi_value* result);
+
 EXTERN_C_END
 
 #endif  // SRC_NODE_API_H_
diff --git a/test/addons-napi/test_general/testNapiRun.js b/test/addons-napi/test_general/testNapiRun.js
new file mode 100644
index 00000000000000..d7534ecf9c3912
--- /dev/null
+++ b/test/addons-napi/test_general/testNapiRun.js
@@ -0,0 +1,12 @@
+'use strict';
+
+const common = require('../../common');
+const assert = require('assert');
+
+// addon is referenced through the eval expression in testFile
+// eslint-disable-next-line no-unused-vars
+const addon = require(`./build/${common.buildType}/test_general`);
+
+assert.strictEqual(addon.testNapiRun('(41.92 + 0.08);'), 42,
+                   'napi_run_script() works correctly');
+assert.throws(() => addon.testNapiRun({ abc: 'def' }), /string was expected/);
diff --git a/test/addons-napi/test_general/test_general.c b/test/addons-napi/test_general/test_general.c
index ea1f2ece0a5d30..287c1d7cb8cb34 100644
--- a/test/addons-napi/test_general/test_general.c
+++ b/test/addons-napi/test_general/test_general.c
@@ -1,4 +1,5 @@
 #include <node_api.h>
+#include <stdlib.h>
 #include "../common.h"
 
 napi_value testStrictEquals(napi_env env, napi_callback_info info) {
@@ -215,12 +216,24 @@ napi_value testAdjustExternalMemory(napi_env env, napi_callback_info info) {
   return result;
 }
 
+napi_value testNapiRun(napi_env env, napi_callback_info info) {
+  napi_value script, result;
+  size_t argc = 1;
+
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &script, NULL, NULL));
+
+  NAPI_CALL(env, napi_run_script(env, script, &result));
+
+  return result;
+}
+
 void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("testStrictEquals", testStrictEquals),
     DECLARE_NAPI_PROPERTY("testGetPrototype", testGetPrototype),
     DECLARE_NAPI_PROPERTY("testGetVersion", testGetVersion),
     DECLARE_NAPI_PROPERTY("testGetNodeVersion", testGetNodeVersion),
+    DECLARE_NAPI_PROPERTY("testNapiRun", testNapiRun),
     DECLARE_NAPI_PROPERTY("doInstanceOf", doInstanceOf),
     DECLARE_NAPI_PROPERTY("getUndefined", getUndefined),
     DECLARE_NAPI_PROPERTY("getNull", getNull),

From 63e86053beef1ca5755f50ff1ff356924f853ac8 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Sat, 9 Sep 2017 12:15:14 +0300
Subject: [PATCH 101/183] n-api: stop creating references to primitives

The binding testing napi_wrap() creates references to primitives passed
into the binding in its second parameter. This is unnecessary and not
at all the point of the test. Additionally, creating persistent
references to primitive values may not be supported by all VMs, since
primitives are best persisted in their native form.

Instead, the point of the test is to make sure that the finalize
callback gets called when it should get called, that it gets called
with the correct pointer, and that it does not get called when it
should not get called. Creating persistent references is not necessary
for verifying this.

PR-URL: https://github.com/nodejs/node/pull/15289
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Re: https://github.com/nodejs/node-chakracore/issues/380
---
 doc/api/n-api.md                             |  2 +-
 src/node_api.cc                              | 10 ++++++++--
 test/addons-napi/test_general/test.js        | 10 +++++-----
 test/addons-napi/test_general/test_general.c | 17 +++++++----------
 4 files changed, 21 insertions(+), 18 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 80d83612509ca1..0efa21056f0e74 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -787,7 +787,7 @@ NODE_EXTERN napi_status napi_create_reference(napi_env env,
 
 - `[in] env`: The environment that the API is invoked under.
 - `[in] value`: `napi_value` representing the Object to which we want
-a reference to.
+a reference.
 - `[in] initial_refcount`: Initial reference count for the new reference.
 - `[out] result`: `napi_ref` pointing to the new reference.
 
diff --git a/src/node_api.cc b/src/node_api.cc
index 9c8e0edec94d40..5b70b9678dd2e7 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -2461,8 +2461,14 @@ napi_status napi_create_reference(napi_env env,
   CHECK_ARG(env, value);
   CHECK_ARG(env, result);
 
-  v8impl::Reference* reference = v8impl::Reference::New(
-      env, v8impl::V8LocalValueFromJsValue(value), initial_refcount, false);
+  v8::Local<v8::Value> v8_value = v8impl::V8LocalValueFromJsValue(value);
+
+  if (!(v8_value->IsObject() || v8_value->IsFunction())) {
+    return napi_set_last_error(env, napi_object_expected);
+  }
+
+  v8impl::Reference* reference =
+      v8impl::Reference::New(env, v8_value, initial_refcount, false);
 
   *result = reinterpret_cast<napi_ref>(reference);
   return napi_clear_last_error(env);
diff --git a/test/addons-napi/test_general/test.js b/test/addons-napi/test_general/test.js
index ec59922639e949..51ce9563a7196e 100644
--- a/test/addons-napi/test_general/test.js
+++ b/test/addons-napi/test_general/test.js
@@ -60,7 +60,7 @@ assert.strictEqual(test_general.testNapiTypeof(null), 'null');
 // Ensure that garbage collecting an object with a wrapped native item results
 // in the finalize callback being called.
 let w = {};
-test_general.wrap(w, []);
+test_general.wrap(w);
 w = null;
 global.gc();
 assert.strictEqual(test_general.derefItemWasCalled(), true,
@@ -69,17 +69,17 @@ assert.strictEqual(test_general.derefItemWasCalled(), true,
 
 // Assert that wrapping twice fails.
 const x = {};
-test_general.wrap(x, 25);
+test_general.wrap(x);
 assert.throws(function() {
-  test_general.wrap(x, 'Blah');
+  test_general.wrap(x);
 }, Error);
 
 // Ensure that wrapping, removing the wrap, and then wrapping again works.
 const y = {};
-test_general.wrap(y, -12);
+test_general.wrap(y);
 test_general.removeWrap(y);
 assert.doesNotThrow(function() {
-  test_general.wrap(y, 're-wrap!');
+  test_general.wrap(y);
 }, Error, 'Wrapping twice succeeds if a remove_wrap() separates the instances');
 
 // Ensure that removing a wrap and garbage collecting does not fire the
diff --git a/test/addons-napi/test_general/test_general.c b/test/addons-napi/test_general/test_general.c
index 287c1d7cb8cb34..048066d25c789b 100644
--- a/test/addons-napi/test_general/test_general.c
+++ b/test/addons-napi/test_general/test_general.c
@@ -143,8 +143,10 @@ static bool deref_item_called = false;
 static void deref_item(napi_env env, void* data, void* hint) {
   (void) hint;
 
+  NAPI_ASSERT_RETURN_VOID(env, data == &deref_item_called,
+    "Finalize callback was called with the correct pointer");
+
   deref_item_called = true;
-  NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, (napi_ref)data));
 }
 
 napi_value deref_item_was_called(napi_env env, napi_callback_info info) {
@@ -156,15 +158,13 @@ napi_value deref_item_was_called(napi_env env, napi_callback_info info) {
 }
 
 napi_value wrap(napi_env env, napi_callback_info info) {
-  size_t argc = 2;
-  napi_value argv[2];
-  napi_ref payload;
+  size_t argc = 1;
+  napi_value to_wrap;
 
   deref_item_called = false;
 
-  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
-  NAPI_CALL(env, napi_create_reference(env, argv[1], 1, &payload));
-  NAPI_CALL(env, napi_wrap(env, argv[0], payload, deref_item, NULL, NULL));
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &to_wrap, NULL, NULL));
+  NAPI_CALL(env, napi_wrap(env, to_wrap, &deref_item_called, deref_item, NULL, NULL));
 
   return NULL;
 }
@@ -176,9 +176,6 @@ napi_value remove_wrap(napi_env env, napi_callback_info info) {
 
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &wrapped, NULL, NULL));
   NAPI_CALL(env, napi_remove_wrap(env, wrapped, &data));
-  if (data != NULL) {
-    NAPI_CALL(env, napi_delete_reference(env, (napi_ref)data));
-  }
 
   return NULL;
 }

From 9c68371202181b11a8a262e99cc9d5d34f1d1a75 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Tue, 8 Aug 2017 20:18:16 +0200
Subject: [PATCH 102/183] n-api: use AsyncResource for Work tracking
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Enable combining N-API async work with async-hooks.

PR-URL: https://github.com/nodejs/node/pull/14697
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
Reviewed-By: Michael Dawson <mhdawson@ibm.com>
---
 doc/api/n-api.md                          | 20 ++++++++++++++
 src/node_api.cc                           | 32 +++++++++++++++++++----
 src/node_api.h                            |  2 ++
 test/addons-napi/test_async/test.js       |  4 +--
 test/addons-napi/test_async/test_async.cc | 31 +++++++++++++---------
 5 files changed, 69 insertions(+), 20 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 0efa21056f0e74..0f04c21bd7fa37 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -3256,10 +3256,16 @@ callback invocation, even when it was cancelled.
 ### napi_create_async_work
 <!-- YAML
 added: v8.0.0
+changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/14697
+    description: Added `async_resource` and `async_resource_name` parameters.
 -->
 ```C
 NAPI_EXTERN
 napi_status napi_create_async_work(napi_env env,
+                                   napi_value async_resource,
+                                   const char* async_resource_name,
                                    napi_async_execute_callback execute,
                                    napi_async_complete_callback complete,
                                    void* data,
@@ -3267,6 +3273,10 @@ napi_status napi_create_async_work(napi_env env,
 ```
 
 - `[in] env`: The environment that the API is invoked under.
+- `[in] async_resource`: An optional object associated with the async work
+  that will be passed to possible async_hooks [`init` hooks][].
+- `[in] async_resource_name`: An identifier for the kind of resource that is
+being provided for diagnostic information exposed by the `async_hooks` API.
 - `[in] execute`: The native function which should be called to excute
 the logic asynchronously.
 - `[in] complete`: The native function which will be called when the
@@ -3282,6 +3292,14 @@ This API allocates a work object that is used to execute logic asynchronously.
 It should be freed using [`napi_delete_async_work`][] once the work is no longer
 required.
 
+`async_resource_name` should be a null-terminated, UTF-8-encoded string.
+
+*Note*: The `async_resource_name` identifier is provided by the user and should
+be representative of the type of async work being performed. It is also
+recommended to apply namespacing to the identifier, e.g. by including the
+module name. See the [`async_hooks` documentation][async_hooks `type`]
+for more information.
+
 ### napi_delete_async_work
 <!-- YAML
 added: v8.0.0
@@ -3637,3 +3655,5 @@ NAPI_EXTERN napi_status napi_run_script(napi_env env,
 [`napi_wrap`]: #n_api_napi_wrap
 
 [`process.release`]: process.html#process_process_release
+[`init` hooks]: async_hooks.html#async_hooks_init_asyncid_type_triggerasyncid_resource
+[async_hooks `type`]: async_hooks.html#async_hooks_type
diff --git a/src/node_api.cc b/src/node_api.cc
index 5b70b9678dd2e7..7a7f6d1b75c8c3 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -3251,13 +3251,18 @@ static napi_status ConvertUVErrorCode(int code) {
 }
 
 // Wrapper around uv_work_t which calls user-provided callbacks.
-class Work {
+class Work : public node::AsyncResource {
  private:
   explicit Work(napi_env env,
-                napi_async_execute_callback execute = nullptr,
+                v8::Local<v8::Object> async_resource,
+                const char* async_resource_name,
+                napi_async_execute_callback execute,
                 napi_async_complete_callback complete = nullptr,
                 void* data = nullptr)
-    : _env(env),
+    : AsyncResource(env->isolate,
+                    async_resource,
+                    async_resource_name),
+    _env(env),
     _data(data),
     _execute(execute),
     _complete(complete) {
@@ -3269,10 +3274,13 @@ class Work {
 
  public:
   static Work* New(napi_env env,
+                   v8::Local<v8::Object> async_resource,
+                   const char* async_resource_name,
                    napi_async_execute_callback execute,
                    napi_async_complete_callback complete,
                    void* data) {
-    return new Work(env, execute, complete, data);
+    return new Work(env, async_resource, async_resource_name,
+                    execute, complete, data);
   }
 
   static void Delete(Work* work) {
@@ -3293,6 +3301,7 @@ class Work {
       // Establish a handle scope here so that every callback doesn't have to.
       // Also it is needed for the exception-handling below.
       v8::HandleScope scope(env->isolate);
+      CallbackScope callback_scope(work);
 
       work->_complete(env, ConvertUVErrorCode(status), work->_data);
 
@@ -3335,6 +3344,8 @@ class Work {
   } while (0)
 
 napi_status napi_create_async_work(napi_env env,
+                                   napi_value async_resource,
+                                   const char* async_resource_name,
                                    napi_async_execute_callback execute,
                                    napi_async_complete_callback complete,
                                    void* data,
@@ -3343,7 +3354,18 @@ napi_status napi_create_async_work(napi_env env,
   CHECK_ARG(env, execute);
   CHECK_ARG(env, result);
 
-  uvimpl::Work* work = uvimpl::Work::New(env, execute, complete, data);
+  v8::Local<v8::Object> resource;
+  if (async_resource != nullptr) {
+    auto value = v8impl::V8LocalValueFromJsValue(async_resource);
+    RETURN_STATUS_IF_FALSE(env, value->IsObject(), napi_invalid_arg);
+    resource = value.As<v8::Object>();
+  } else {
+    resource = v8::Object::New(env->isolate);
+  }
+
+  uvimpl::Work* work =
+      uvimpl::Work::New(env, resource, async_resource_name,
+                        execute, complete, data);
 
   *result = reinterpret_cast<napi_async_work>(work);
 
diff --git a/src/node_api.h b/src/node_api.h
index 807595777dd947..227f26a2ffb6fb 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -524,6 +524,8 @@ NAPI_EXTERN napi_status napi_get_dataview_info(napi_env env,
 // Methods to manage simple async operations
 NAPI_EXTERN
 napi_status napi_create_async_work(napi_env env,
+                                   napi_value async_resource,
+                                   const char* async_resource_name,
                                    napi_async_execute_callback execute,
                                    napi_async_complete_callback complete,
                                    void* data,
diff --git a/test/addons-napi/test_async/test.js b/test/addons-napi/test_async/test.js
index cfd39a5b11ae2d..749c48e05798a8 100644
--- a/test/addons-napi/test_async/test.js
+++ b/test/addons-napi/test_async/test.js
@@ -9,7 +9,7 @@ const testException = 'test_async_cb_exception';
 // Exception thrown from async completion callback.
 // (Tested in a spawned process because the exception is fatal.)
 if (process.argv[2] === 'child') {
-  test_async.Test(1, common.mustCall(function() {
+  test_async.Test(1, {}, common.mustCall(function() {
     throw new Error(testException);
   }));
   return;
@@ -20,7 +20,7 @@ assert.ifError(p.error);
 assert.ok(p.stderr.toString().includes(testException));
 
 // Successful async execution and completion callback.
-test_async.Test(5, common.mustCall(function(err, val) {
+test_async.Test(5, {}, common.mustCall(function(err, val) {
   assert.strictEqual(err, null);
   assert.strictEqual(val, 10);
   process.nextTick(common.mustCall());
diff --git a/test/addons-napi/test_async/test_async.cc b/test/addons-napi/test_async/test_async.cc
index ca76fa2d33b132..bd54c77efe5e58 100644
--- a/test/addons-napi/test_async/test_async.cc
+++ b/test/addons-napi/test_async/test_async.cc
@@ -61,37 +61,40 @@ void Complete(napi_env env, napi_status status, void* data) {
 
   napi_value result;
   NAPI_CALL_RETURN_VOID(env,
-    napi_make_callback(env, global, callback, 2, argv, &result));
+    napi_call_function(env, global, callback, 2, argv, &result));
 
   NAPI_CALL_RETURN_VOID(env, napi_delete_reference(env, c->_callback));
   NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, c->_request));
 }
 
 napi_value Test(napi_env env, napi_callback_info info) {
-  size_t argc = 2;
-  napi_value argv[2];
+  size_t argc = 3;
+  napi_value argv[3];
   napi_value _this;
   void* data;
   NAPI_CALL(env,
     napi_get_cb_info(env, info, &argc, argv, &_this, &data));
-  NAPI_ASSERT(env, argc >= 2, "Not enough arguments, expected 2.");
+  NAPI_ASSERT(env, argc >= 3, "Not enough arguments, expected 2.");
 
   napi_valuetype t;
   NAPI_CALL(env, napi_typeof(env, argv[0], &t));
   NAPI_ASSERT(env, t == napi_number,
     "Wrong first argument, integer expected.");
   NAPI_CALL(env, napi_typeof(env, argv[1], &t));
+  NAPI_ASSERT(env, t == napi_object,
+    "Wrong second argument, object expected.");
+  NAPI_CALL(env, napi_typeof(env, argv[2], &t));
   NAPI_ASSERT(env, t == napi_function,
-    "Wrong second argument, function expected.");
+    "Wrong third argument, function expected.");
 
   the_carrier._output = 0;
 
   NAPI_CALL(env,
     napi_get_value_int32(env, argv[0], &the_carrier._input));
   NAPI_CALL(env,
-    napi_create_reference(env, argv[1], 1, &the_carrier._callback));
-  NAPI_CALL(env, napi_create_async_work(
-    env, Execute, Complete, &the_carrier, &the_carrier._request));
+    napi_create_reference(env, argv[2], 1, &the_carrier._callback));
+  NAPI_CALL(env, napi_create_async_work(env, argv[1], "TestResource",
+    Execute, Complete, &the_carrier, &the_carrier._request));
   NAPI_CALL(env,
     napi_queue_async_work(env, the_carrier._request));
 
@@ -116,7 +119,7 @@ void CancelComplete(napi_env env, napi_status status, void* data) {
     NAPI_CALL_RETURN_VOID(env, napi_get_global(env, &global));
     napi_value result;
     NAPI_CALL_RETURN_VOID(env,
-      napi_make_callback(env, global, callback, 0, nullptr, &result));
+      napi_call_function(env, global, callback, 0, nullptr, &result));
   }
 
   NAPI_CALL_RETURN_VOID(env, napi_delete_async_work(env, c->_request));
@@ -140,8 +143,9 @@ napi_value TestCancel(napi_env env, napi_callback_info info) {
   // make sure the work we are going to cancel will not be
   // able to start by using all the threads in the pool
   for (int i = 1; i < MAX_CANCEL_THREADS; i++) {
-    NAPI_CALL(env, napi_create_async_work(env, CancelExecute,
-      BusyCancelComplete, &async_carrier[i], &async_carrier[i]._request));
+    NAPI_CALL(env, napi_create_async_work(env, nullptr, "TestCancelBusy",
+      CancelExecute, BusyCancelComplete,
+      &async_carrier[i], &async_carrier[i]._request));
     NAPI_CALL(env, napi_queue_async_work(env, async_carrier[i]._request));
   }
 
@@ -151,8 +155,9 @@ napi_value TestCancel(napi_env env, napi_callback_info info) {
   // workers above.
   NAPI_CALL(env,
     napi_get_cb_info(env, info, &argc, argv, &_this, &data));
-  NAPI_CALL(env, napi_create_async_work(env, CancelExecute,
-    CancelComplete, &async_carrier[0], &async_carrier[0]._request));
+  NAPI_CALL(env, napi_create_async_work(env, nullptr, "TestCancelled",
+    CancelExecute, CancelComplete,
+    &async_carrier[0], &async_carrier[0]._request));
   NAPI_CALL(env,
     napi_create_reference(env, argv[0], 1, &async_carrier[0]._callback));
   NAPI_CALL(env, napi_queue_async_work(env, async_carrier[0]._request));

From 14dc0f872bef46b0268a42e8b2431789cc76f945 Mon Sep 17 00:00:00 2001
From: Jason Ginchereau <jasongin@microsoft.com>
Date: Sat, 9 Sep 2017 14:04:35 -0700
Subject: [PATCH 103/183] n-api: change async resource name to napi_value

PR-URL: https://github.com/nodejs/node/pull/14697
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 doc/api/n-api.md                          |  2 +-
 node.gyp                                  |  1 +
 src/node_api.cc                           | 17 +++--
 src/node_api.h                            |  2 +-
 src/node_api_backport.cc                  | 89 +++++++++++++++++++++++
 src/node_api_backport.h                   | 44 ++++++++++-
 test/addons-napi/test_async/test_async.cc | 14 +++-
 7 files changed, 156 insertions(+), 13 deletions(-)
 create mode 100644 src/node_api_backport.cc

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 0f04c21bd7fa37..cf0b6cc6edd46f 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -3265,7 +3265,7 @@ changes:
 NAPI_EXTERN
 napi_status napi_create_async_work(napi_env env,
                                    napi_value async_resource,
-                                   const char* async_resource_name,
+                                   napi_value async_resource_name,
                                    napi_async_execute_callback execute,
                                    napi_async_complete_callback complete,
                                    void* data,
diff --git a/node.gyp b/node.gyp
index e37aadc036ef59..7458e84621b983 100644
--- a/node.gyp
+++ b/node.gyp
@@ -241,6 +241,7 @@
         'src/handle_wrap.cc',
         'src/js_stream.cc',
         'src/node.cc',
+        'src/node_api_backport.cc',
         'src/node_api.cc',
         'src/node_api.h',
         'src/node_api_types.h',
diff --git a/src/node_api.cc b/src/node_api.cc
index 7a7f6d1b75c8c3..a62ab51f88b024 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -3255,7 +3255,7 @@ class Work : public node::AsyncResource {
  private:
   explicit Work(napi_env env,
                 v8::Local<v8::Object> async_resource,
-                const char* async_resource_name,
+                v8::Local<v8::String> async_resource_name,
                 napi_async_execute_callback execute,
                 napi_async_complete_callback complete = nullptr,
                 void* data = nullptr)
@@ -3275,7 +3275,7 @@ class Work : public node::AsyncResource {
  public:
   static Work* New(napi_env env,
                    v8::Local<v8::Object> async_resource,
-                   const char* async_resource_name,
+                   v8::Local<v8::String> async_resource_name,
                    napi_async_execute_callback execute,
                    napi_async_complete_callback complete,
                    void* data) {
@@ -3345,7 +3345,7 @@ class Work : public node::AsyncResource {
 
 napi_status napi_create_async_work(napi_env env,
                                    napi_value async_resource,
-                                   const char* async_resource_name,
+                                   napi_value async_resource_name,
                                    napi_async_execute_callback execute,
                                    napi_async_complete_callback complete,
                                    void* data,
@@ -3354,17 +3354,20 @@ napi_status napi_create_async_work(napi_env env,
   CHECK_ARG(env, execute);
   CHECK_ARG(env, result);
 
+  v8::Local<v8::Context> context = env->isolate->GetCurrentContext();
+
   v8::Local<v8::Object> resource;
   if (async_resource != nullptr) {
-    auto value = v8impl::V8LocalValueFromJsValue(async_resource);
-    RETURN_STATUS_IF_FALSE(env, value->IsObject(), napi_invalid_arg);
-    resource = value.As<v8::Object>();
+    CHECK_TO_OBJECT(env, context, resource, async_resource);
   } else {
     resource = v8::Object::New(env->isolate);
   }
 
+  v8::Local<v8::String> resource_name;
+  CHECK_TO_STRING(env, context, resource_name, async_resource_name);
+
   uvimpl::Work* work =
-      uvimpl::Work::New(env, resource, async_resource_name,
+      uvimpl::Work::New(env, resource, resource_name,
                         execute, complete, data);
 
   *result = reinterpret_cast<napi_async_work>(work);
diff --git a/src/node_api.h b/src/node_api.h
index 227f26a2ffb6fb..b127fd7fe80070 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -525,7 +525,7 @@ NAPI_EXTERN napi_status napi_get_dataview_info(napi_env env,
 NAPI_EXTERN
 napi_status napi_create_async_work(napi_env env,
                                    napi_value async_resource,
-                                   const char* async_resource_name,
+                                   napi_value async_resource_name,
                                    napi_async_execute_callback execute,
                                    napi_async_complete_callback complete,
                                    void* data,
diff --git a/src/node_api_backport.cc b/src/node_api_backport.cc
new file mode 100644
index 00000000000000..249e3e8100efef
--- /dev/null
+++ b/src/node_api_backport.cc
@@ -0,0 +1,89 @@
+#include "node_api_backport.h"
+
+using v8::Function;
+using v8::HandleScope;
+using v8::Local;
+using v8::MaybeLocal;
+using v8::Object;
+using v8::TryCatch;
+using v8::Value;
+
+namespace node {
+
+CallbackScope::CallbackScope(v8::Isolate *_isolate,
+                             v8::Local<v8::Object> _object,
+                             node::async_context context) :
+    isolate(_isolate),
+    env(node::Environment::GetCurrent(isolate->GetCurrentContext())),
+    _try_catch(isolate),
+    object(_object),
+    callback_scope(
+        node::Environment::GetCurrent(isolate->GetCurrentContext())) {
+  Local<Function> pre_fn = env->async_hooks_pre_function();
+
+  Local<Value> async_queue_v = object->Get(env->async_queue_string());
+  if (async_queue_v->IsObject())
+    ran_init_callback = true;
+
+  if (ran_init_callback && !pre_fn.IsEmpty()) {
+    TryCatch try_catch(env->isolate());
+    MaybeLocal<Value> ar = pre_fn->Call(env->context(), object, 0, nullptr);
+    if (ar.IsEmpty()) {
+      ClearFatalExceptionHandlers(env);
+      FatalException(env->isolate(), try_catch);
+    }
+  }
+}
+
+CallbackScope::~CallbackScope() {
+  Local<Function> post_fn = env->async_hooks_post_function();
+  if (ran_init_callback && !post_fn.IsEmpty()) {
+    Local<Value> did_throw = v8::Boolean::New(isolate, _try_catch.HasCaught());
+    // Currently there's no way to retrieve an uid from node::MakeCallback().
+    // This needs to be fixed.
+    Local<Value> vals[] =
+        { Undefined(env->isolate()).As<Value>(), did_throw };
+    TryCatch try_catch(env->isolate());
+    MaybeLocal<Value> ar =
+        post_fn->Call(env->context(), object, arraysize(vals), vals);
+    if (ar.IsEmpty()) {
+      ClearFatalExceptionHandlers(env);
+      FatalException(env->isolate(), try_catch);
+      return;
+    }
+  }
+
+  if (callback_scope.in_makecallback()) {
+    return;
+  }
+
+  Environment::TickInfo* tick_info = env->tick_info();
+
+  if (tick_info->length() == 0) {
+    env->isolate()->RunMicrotasks();
+  }
+
+  if (tick_info->length() == 0) {
+    tick_info->set_index(0);
+    return;
+  }
+
+  env->tick_callback_function()->Call(env->process_object(), 0, nullptr);
+}
+
+AsyncResource::AsyncResource(v8::Isolate* _isolate,
+                             v8::Local<v8::Object> _object,
+                             v8::Local<v8::String> name) : isolate(_isolate) {
+  object.Reset(isolate, _object);
+}
+
+AsyncResource::~AsyncResource() {
+  object.Reset();
+}
+
+}  // end of namespace node
+
+CallbackScope::CallbackScope(node::AsyncResource* work) :
+    scope(work->isolate,
+          v8::Local<Object>::New(work->isolate,
+          work->object), {0, 0}) {}
diff --git a/src/node_api_backport.h b/src/node_api_backport.h
index da607735a36b74..549b3ed42033de 100644
--- a/src/node_api_backport.h
+++ b/src/node_api_backport.h
@@ -5,6 +5,48 @@
 // which have appeared in later versions of Node.js, and which are required for
 // N-API.
 
-#define ToChecked FromJust
+#include "node_internals.h"
+
+namespace node {
+
+typedef int async_id;
+
+typedef struct async_context {
+  node::async_id async_id;
+  node::async_id trigger_async_id;
+} async_context;
+
+class CallbackScope {
+ public:
+  CallbackScope(v8::Isolate *isolate,
+                v8::Local<v8::Object> object,
+                node::async_context context);
+  ~CallbackScope();
+ private:
+  v8::Isolate* isolate = nullptr;
+  node::Environment* env = nullptr;
+  v8::TryCatch _try_catch;
+  bool ran_init_callback = false;
+  v8::Local<v8::Object> object;
+  Environment::AsyncCallbackScope callback_scope;
+};
+
+class AsyncResource {
+ public:
+  AsyncResource(v8::Isolate* _isolate,
+                v8::Local<v8::Object> _object,
+                v8::Local<v8::String> name);
+  ~AsyncResource();
+  v8::Isolate* isolate;
+  v8::Persistent<v8::Object> object;
+};
+}  // end of namespace node
+
+class CallbackScope {
+ public:
+  explicit CallbackScope(node::AsyncResource* work);
+ private:
+  node::CallbackScope scope;
+};
 
 #endif  // SRC_NODE_API_BACKPORT_H_
diff --git a/test/addons-napi/test_async/test_async.cc b/test/addons-napi/test_async/test_async.cc
index bd54c77efe5e58..71b1c03fba0cf8 100644
--- a/test/addons-napi/test_async/test_async.cc
+++ b/test/addons-napi/test_async/test_async.cc
@@ -71,6 +71,7 @@ napi_value Test(napi_env env, napi_callback_info info) {
   size_t argc = 3;
   napi_value argv[3];
   napi_value _this;
+  napi_value resource_name;
   void* data;
   NAPI_CALL(env,
     napi_get_cb_info(env, info, &argc, argv, &_this, &data));
@@ -93,7 +94,10 @@ napi_value Test(napi_env env, napi_callback_info info) {
     napi_get_value_int32(env, argv[0], &the_carrier._input));
   NAPI_CALL(env,
     napi_create_reference(env, argv[2], 1, &the_carrier._callback));
-  NAPI_CALL(env, napi_create_async_work(env, argv[1], "TestResource",
+
+  NAPI_CALL(env,
+    napi_create_string_utf8(env, "TestResource", -1, &resource_name));
+  NAPI_CALL(env, napi_create_async_work(env, argv[1], resource_name,
     Execute, Complete, &the_carrier, &the_carrier._request));
   NAPI_CALL(env,
     napi_queue_async_work(env, the_carrier._request));
@@ -138,12 +142,16 @@ napi_value TestCancel(napi_env env, napi_callback_info info) {
   size_t argc = 1;
   napi_value argv[1];
   napi_value _this;
+  napi_value resource_name;
   void* data;
 
+  NAPI_CALL(env,
+    napi_create_string_utf8(env, "TestResource", -1, &resource_name));
+
   // make sure the work we are going to cancel will not be
   // able to start by using all the threads in the pool
   for (int i = 1; i < MAX_CANCEL_THREADS; i++) {
-    NAPI_CALL(env, napi_create_async_work(env, nullptr, "TestCancelBusy",
+    NAPI_CALL(env, napi_create_async_work(env, nullptr, resource_name,
       CancelExecute, BusyCancelComplete,
       &async_carrier[i], &async_carrier[i]._request));
     NAPI_CALL(env, napi_queue_async_work(env, async_carrier[i]._request));
@@ -155,7 +163,7 @@ napi_value TestCancel(napi_env env, napi_callback_info info) {
   // workers above.
   NAPI_CALL(env,
     napi_get_cb_info(env, info, &argc, argv, &_this, &data));
-  NAPI_CALL(env, napi_create_async_work(env, nullptr, "TestCancelled",
+  NAPI_CALL(env, napi_create_async_work(env, nullptr, resource_name,
     CancelExecute, CancelComplete,
     &async_carrier[0], &async_carrier[0]._request));
   NAPI_CALL(env,

From ab1870a4f503f197af2b303a1dd7fe0101f42020 Mon Sep 17 00:00:00 2001
From: Taylor Woll <taylor.woll@microsoft.com>
Date: Wed, 30 Aug 2017 02:48:41 -0700
Subject: [PATCH 104/183] n-api: refactor napi_addon_register_func

As per discussion in abi-stable-node:
https://github.com/nodejs/abi-stable-node/issues/256,
take a refactor to napi_addon_register_func such that
the result from the register function is assigned to
the module exports property. By making this change,
native module can be agnostic about which type of
module the environment supports.

PR-URL: https://github.com/nodejs/node/pull/15088
Reviewed-By: Gabriel Schulhof <gabriel.schulhof@intel.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Hitesh Kanwathirtha <digitalinfinity@gmail.com>
---
 doc/api/n-api.md                              | 55 +++++++++++--------
 src/node_api.cc                               | 16 ++++--
 src/node_api.h                                |  6 +-
 test/addons-napi/1_hello_world/binding.c      |  5 +-
 .../2_function_arguments/binding.c            |  7 ++-
 test/addons-napi/3_callbacks/binding.c        | 11 ++--
 test/addons-napi/4_object_factory/binding.c   |  8 +--
 test/addons-napi/5_function_factory/binding.c | 10 ++--
 test/addons-napi/6_object_wrap/binding.cc     |  4 +-
 test/addons-napi/6_object_wrap/myobject.cc    | 18 +++---
 test/addons-napi/7_factory_wrap/binding.cc    | 10 ++--
 test/addons-napi/7_factory_wrap/myobject.cc   | 12 ++--
 test/addons-napi/8_passing_wrapped/binding.cc |  8 ++-
 test/addons-napi/test_array/test_array.c      | 24 ++++----
 test/addons-napi/test_async/test_async.cc     | 20 ++++---
 test/addons-napi/test_buffer/test_buffer.c    | 25 +++++----
 .../test_constructor/test_constructor.c       | 14 ++---
 .../test_conversions/test_conversions.c       |  8 ++-
 .../addons-napi/test_dataview/test_dataview.c |  6 +-
 .../test_env_sharing/compare_env.c            |  6 +-
 test/addons-napi/test_env_sharing/store_env.c |  8 +--
 test/addons-napi/test_error/test_error.cc     |  8 ++-
 .../test_exception/test_exception.c           |  8 ++-
 test/addons-napi/test_fatal/test_fatal.c      |  6 +-
 .../addons-napi/test_function/test_function.c |  9 +--
 test/addons-napi/test_general/test_general.c  | 12 ++--
 .../test_handle_scope/test_handle_scope.c     | 16 +++---
 .../addons-napi/test_make_callback/binding.cc |  9 ++-
 .../test_make_callback_recurse/binding.cc     | 12 ++--
 test/addons-napi/test_number/test_number.c    | 12 ++--
 test/addons-napi/test_object/test_object.c    | 28 +++++-----
 test/addons-napi/test_promise/test_promise.c  |  8 ++-
 .../test_properties/test_properties.c         | 34 ++++++------
 .../test_reference/test_reference.c           | 46 ++++++++--------
 test/addons-napi/test_string/test_string.c    | 36 ++++++------
 test/addons-napi/test_symbol/test_symbol.c    | 14 +++--
 .../test_typedarray/test_typedarray.c         | 55 ++++++++++---------
 37 files changed, 322 insertions(+), 272 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index cf0b6cc6edd46f..7d61dc055048e2 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -873,7 +873,7 @@ JavaScript Object associated with the `napi_ref`. Otherise, result
 will be NULL.
 
 ## Module registration
-N-API modules are registered in the same manner as other modules
+N-API modules are registered in a manner similar to other modules
 except that instead of using the `NODE_MODULE` macro the following
 is used:
 
@@ -885,32 +885,39 @@ The next difference is the signature for the `Init` method. For a N-API
 module it is as follows:
 
 ```C
-void Init(napi_env env, napi_value exports, napi_value module, void* priv);
+napi_value Init(napi_env env, napi_value exports);
 ```
 
-As with any other module, functions are exported by either adding them to
-the `exports` or `module` objects passed to the `Init` method.
+The return value from `Init` is treated as the `exports` object for the module.
+The `Init` method is passed an empty object via the `exports` parameter as a
+convenience. If `Init` returns NULL, the parameter passed as `exports` is
+exported by the module. N-API modules cannot modify the `module` object but can
+specify anything as the `exports` property of the module.
 
 For example, to add the method `hello` as a function so that it can be called
 as a method provided by the addon:
 
 ```C
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_status status;
   napi_property_descriptor desc =
     {"hello", Method, 0, 0, 0, napi_default, 0};
+  if (status != napi_ok) return nullptr;
   status = napi_define_properties(env, exports, 1, &desc);
+  if (status != napi_ok) return nullptr;
+  return exports;
 }
 ```
 
 For example, to set a function to be returned by the `require()` for the addon:
 
 ```C
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
+  napi_value method;
   napi_status status;
-  napi_property_descriptor desc =
-    {"exports", Method, 0, 0, 0, napi_default, 0};
-  status = napi_define_properties(env, module, 1, &desc);
+  status = napi_create_function(env, "exports", Method, NULL, &method));
+  if (status != napi_ok) return nullptr;
+  return method;
 }
 ```
 
@@ -919,28 +926,30 @@ For example, to define a class so that new instances can be created
 
 ```C
 // NOTE: partial example, not all referenced code is included
-
-napi_status status;
-napi_property_descriptor properties[] = {
+napi_value Init(napi_env env, napi_value exports) {
+  napi_status status;
+  napi_property_descriptor properties[] = {
     { "value", nullptr, GetValue, SetValue, 0, napi_default, 0 },
     DECLARE_NAPI_METHOD("plusOne", PlusOne),
     DECLARE_NAPI_METHOD("multiply", Multiply),
-};
+  };
 
-napi_value cons;
-status =
-    napi_define_class(env, "MyObject", New, nullptr, 3, properties, &cons);
-if (status != napi_ok) return;
+  napi_value cons;
+  status =
+      napi_define_class(env, "MyObject", New, nullptr, 3, properties, &cons);
+  if (status != napi_ok) return nullptr;
 
-status = napi_create_reference(env, cons, 1, &constructor);
-if (status != napi_ok) return;
+  status = napi_create_reference(env, cons, 1, &constructor);
+  if (status != napi_ok) return nullptr;
 
-status = napi_set_named_property(env, exports, "MyObject", cons);
-if (status != napi_ok) return;
+  status = napi_set_named_property(env, exports, "MyObject", cons);
+  if (status != napi_ok) return nullptr;
+
+  return exports;
+}
 ```
 
-For more details on setting properties on either the `exports` or `module`
-objects, see the section on
+For more details on setting properties on objects, see the section on
 [Working with JavaScript Properties][].
 
 For more details on building addon modules in general, refer to the existing API
diff --git a/src/node_api.cc b/src/node_api.cc
index a62ab51f88b024..5efb6b4f549e6a 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -829,11 +829,17 @@ void napi_module_register_cb(v8::Local<v8::Object> exports,
   // one is found.
   napi_env env = v8impl::GetEnv(context);
 
-  mod->nm_register_func(
-    env,
-    v8impl::JsValueFromV8LocalValue(exports),
-    v8impl::JsValueFromV8LocalValue(module),
-    mod->nm_priv);
+  napi_value _exports =
+      mod->nm_register_func(env, v8impl::JsValueFromV8LocalValue(exports));
+
+  // If register function returned a non-null exports object different from
+  // the exports object we passed it, set that as the "exports" property of
+  // the module.
+  if (_exports != nullptr &&
+      _exports != v8impl::JsValueFromV8LocalValue(exports)) {
+    napi_value _module = v8impl::JsValueFromV8LocalValue(module);
+    napi_set_named_property(env, _module, "exports", _exports);
+  }
 }
 
 #ifndef EXTERNAL_NAPI
diff --git a/src/node_api.h b/src/node_api.h
index b127fd7fe80070..cdc3a6bdb7ebe3 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -44,10 +44,8 @@
 #endif
 
 
-typedef void (*napi_addon_register_func)(napi_env env,
-                                         napi_value exports,
-                                         napi_value module,
-                                         void* priv);
+typedef napi_value (*napi_addon_register_func)(napi_env env,
+                                               napi_value exports);
 
 typedef struct {
   int nm_version;
diff --git a/test/addons-napi/1_hello_world/binding.c b/test/addons-napi/1_hello_world/binding.c
index 57bac37fa0bfd1..00f75e3a615b60 100644
--- a/test/addons-napi/1_hello_world/binding.c
+++ b/test/addons-napi/1_hello_world/binding.c
@@ -10,9 +10,10 @@ napi_value Method(napi_env env, napi_callback_info info) {
   return world;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor desc = DECLARE_NAPI_PROPERTY("hello", Method);
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(env, exports, 1, &desc));
+  NAPI_CALL(env, napi_define_properties(env, exports, 1, &desc));
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/2_function_arguments/binding.c b/test/addons-napi/2_function_arguments/binding.c
index 92f89fd2ffa199..d6f7e99a6d72c7 100644
--- a/test/addons-napi/2_function_arguments/binding.c
+++ b/test/addons-napi/2_function_arguments/binding.c
@@ -15,7 +15,7 @@ napi_value Add(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
 
   NAPI_ASSERT(env, valuetype0 == napi_number && valuetype1 == napi_number,
-    "Wrong argument type. Numbers expected.");
+      "Wrong argument type. Numbers expected.");
 
   double value0;
   NAPI_CALL(env, napi_get_value_double(env, args[0], &value0));
@@ -29,9 +29,10 @@ napi_value Add(napi_env env, napi_callback_info info) {
   return sum;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor desc = DECLARE_NAPI_PROPERTY("add", Add);
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(env, exports, 1, &desc));
+  NAPI_CALL(env, napi_define_properties(env, exports, 1, &desc));
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/3_callbacks/binding.c b/test/addons-napi/3_callbacks/binding.c
index 8640a936107d47..b9e6abd3965de5 100644
--- a/test/addons-napi/3_callbacks/binding.c
+++ b/test/addons-napi/3_callbacks/binding.c
@@ -8,17 +8,17 @@ napi_value RunCallback(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   NAPI_ASSERT(env, argc == 1,
-    "Wrong number of arguments. Expects a single argument.");
+      "Wrong number of arguments. Expects a single argument.");
 
   napi_valuetype valuetype0;
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
   NAPI_ASSERT(env, valuetype0 == napi_function,
-    "Wrong type of arguments. Expects a function as first argument.");
+      "Wrong type of arguments. Expects a function as first argument.");
 
   napi_valuetype valuetype1;
   NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
   NAPI_ASSERT(env, valuetype1 == napi_undefined,
-    "Additional arguments should be undefined.");
+      "Additional arguments should be undefined.");
 
   napi_value argv[1];
   const char* str = "hello world";
@@ -45,12 +45,13 @@ napi_value RunCallbackWithRecv(napi_env env, napi_callback_info info) {
   return NULL;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor desc[2] = {
     DECLARE_NAPI_PROPERTY("RunCallback", RunCallback),
     DECLARE_NAPI_PROPERTY("RunCallbackWithRecv", RunCallbackWithRecv),
   };
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(env, exports, 2, desc));
+  NAPI_CALL(env, napi_define_properties(env, exports, 2, desc));
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/4_object_factory/binding.c b/test/addons-napi/4_object_factory/binding.c
index d76f30b847a237..fe509c02ad13b6 100644
--- a/test/addons-napi/4_object_factory/binding.c
+++ b/test/addons-napi/4_object_factory/binding.c
@@ -14,10 +14,10 @@ napi_value CreateObject(napi_env env, napi_callback_info info) {
   return obj;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_property_descriptor desc =
-    DECLARE_NAPI_PROPERTY("exports", CreateObject);
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(env, module, 1, &desc));
+napi_value Init(napi_env env, napi_value exports) {
+  NAPI_CALL(env,
+      napi_create_function(env, "exports", CreateObject, NULL, &exports));
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/5_function_factory/binding.c b/test/addons-napi/5_function_factory/binding.c
index 4c20190f5047cd..a2e03dd9bdd6b5 100644
--- a/test/addons-napi/5_function_factory/binding.c
+++ b/test/addons-napi/5_function_factory/binding.c
@@ -11,15 +11,15 @@ napi_value MyFunction(napi_env env, napi_callback_info info) {
 napi_value CreateFunction(napi_env env, napi_callback_info info) {
   napi_value fn;
   NAPI_CALL(env,
-    napi_create_function(env, "theFunction", MyFunction, NULL, &fn));
+      napi_create_function(env, "theFunction", MyFunction, NULL, &fn));
 
   return fn;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  napi_property_descriptor desc =
-    DECLARE_NAPI_PROPERTY("exports", CreateFunction);
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(env, module, 1, &desc));
+napi_value Init(napi_env env, napi_value exports) {
+  NAPI_CALL(env,
+      napi_create_function(env, "exports", CreateFunction, NULL, &exports));
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/6_object_wrap/binding.cc b/test/addons-napi/6_object_wrap/binding.cc
index 99d8339bd09ef3..1481573a92226c 100644
--- a/test/addons-napi/6_object_wrap/binding.cc
+++ b/test/addons-napi/6_object_wrap/binding.cc
@@ -1,7 +1,9 @@
 #include "myobject.h"
+#include "../common.h"
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   MyObject::Init(env, exports);
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/6_object_wrap/myobject.cc b/test/addons-napi/6_object_wrap/myobject.cc
index 56b00ddae49a32..c214e014b9eb12 100644
--- a/test/addons-napi/6_object_wrap/myobject.cc
+++ b/test/addons-napi/6_object_wrap/myobject.cc
@@ -23,12 +23,12 @@ void MyObject::Init(napi_env env, napi_value exports) {
 
   napi_value cons;
   NAPI_CALL_RETURN_VOID(env,
-    napi_define_class(env, "MyObject", New, nullptr, 3, properties, &cons));
+      napi_define_class(env, "MyObject", New, nullptr, 3, properties, &cons));
 
   NAPI_CALL_RETURN_VOID(env, napi_create_reference(env, cons, 1, &constructor));
 
   NAPI_CALL_RETURN_VOID(env,
-    napi_set_named_property(env, exports, "MyObject", cons));
+      napi_set_named_property(env, exports, "MyObject", cons));
 }
 
 napi_value MyObject::New(napi_env env, napi_callback_info info) {
@@ -55,11 +55,11 @@ napi_value MyObject::New(napi_env env, napi_callback_info info) {
 
     obj->env_ = env;
     NAPI_CALL(env, napi_wrap(env,
-                            _this,
-                            obj,
-                            MyObject::Destructor,
-                            nullptr,  // finalize_hint
-                            &obj->wrapper_));
+                             _this,
+                             obj,
+                             MyObject::Destructor,
+                             nullptr,  // finalize_hint
+                             &obj->wrapper_));
 
     return _this;
   }
@@ -80,7 +80,7 @@ napi_value MyObject::New(napi_env env, napi_callback_info info) {
 napi_value MyObject::GetValue(napi_env env, napi_callback_info info) {
   napi_value _this;
   NAPI_CALL(env,
-    napi_get_cb_info(env, info, nullptr, nullptr, &_this, nullptr));
+      napi_get_cb_info(env, info, nullptr, nullptr, &_this, nullptr));
 
   MyObject* obj;
   NAPI_CALL(env, napi_unwrap(env, _this, reinterpret_cast<void**>(&obj)));
@@ -108,7 +108,7 @@ napi_value MyObject::SetValue(napi_env env, napi_callback_info info) {
 napi_value MyObject::PlusOne(napi_env env, napi_callback_info info) {
   napi_value _this;
   NAPI_CALL(env,
-    napi_get_cb_info(env, info, nullptr, nullptr, &_this, nullptr));
+      napi_get_cb_info(env, info, nullptr, nullptr, &_this, nullptr));
 
   MyObject* obj;
   NAPI_CALL(env, napi_unwrap(env, _this, reinterpret_cast<void**>(&obj)));
diff --git a/test/addons-napi/7_factory_wrap/binding.cc b/test/addons-napi/7_factory_wrap/binding.cc
index c61e4094784ed7..4d02247f85b924 100644
--- a/test/addons-napi/7_factory_wrap/binding.cc
+++ b/test/addons-napi/7_factory_wrap/binding.cc
@@ -12,12 +12,12 @@ napi_value CreateObject(napi_env env, napi_callback_info info) {
   return instance;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
-  NAPI_CALL_RETURN_VOID(env, MyObject::Init(env));
+napi_value Init(napi_env env, napi_value exports) {
+  NAPI_CALL(env, MyObject::Init(env));
 
-  napi_property_descriptor desc =
-    DECLARE_NAPI_PROPERTY("exports", CreateObject);
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(env, module, 1, &desc));
+  NAPI_CALL(env,
+      napi_create_function(env, "exports", CreateObject, NULL, &exports));
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/7_factory_wrap/myobject.cc b/test/addons-napi/7_factory_wrap/myobject.cc
index 4a2b284439ddb9..c6d538a7cefbc6 100644
--- a/test/addons-napi/7_factory_wrap/myobject.cc
+++ b/test/addons-napi/7_factory_wrap/myobject.cc
@@ -50,11 +50,11 @@ napi_value MyObject::New(napi_env env, napi_callback_info info) {
 
   obj->env_ = env;
   NAPI_CALL(env, napi_wrap(env,
-                          _this,
-                          obj,
-                          MyObject::Destructor,
-                          nullptr, /* finalize_hint */
-                          &obj->wrapper_));
+                           _this,
+                           obj,
+                           MyObject::Destructor,
+                           nullptr, /* finalize_hint */
+                           &obj->wrapper_));
 
   return _this;
 }
@@ -80,7 +80,7 @@ napi_status MyObject::NewInstance(napi_env env,
 napi_value MyObject::PlusOne(napi_env env, napi_callback_info info) {
   napi_value _this;
   NAPI_CALL(env,
-    napi_get_cb_info(env, info, nullptr, nullptr, &_this, nullptr));
+      napi_get_cb_info(env, info, nullptr, nullptr, &_this, nullptr));
 
   MyObject* obj;
   NAPI_CALL(env, napi_unwrap(env, _this, reinterpret_cast<void**>(&obj)));
diff --git a/test/addons-napi/8_passing_wrapped/binding.cc b/test/addons-napi/8_passing_wrapped/binding.cc
index c22ac6442f6c4e..86a6e4d739f03d 100644
--- a/test/addons-napi/8_passing_wrapped/binding.cc
+++ b/test/addons-napi/8_passing_wrapped/binding.cc
@@ -29,7 +29,7 @@ napi_value Add(napi_env env, napi_callback_info info) {
   return sum;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   MyObject::Init(env);
 
   napi_property_descriptor desc[] = {
@@ -37,8 +37,10 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("add", Add),
   };
 
-  NAPI_CALL_RETURN_VOID(env,
-    napi_define_properties(env, exports, sizeof(desc) / sizeof(*desc), desc));
+  NAPI_CALL(env,
+      napi_define_properties(env, exports, sizeof(desc) / sizeof(*desc), desc));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_array/test_array.c b/test/addons-napi/test_array/test_array.c
index 4bb12d4e01e8fa..74207560227c48 100644
--- a/test/addons-napi/test_array/test_array.c
+++ b/test/addons-napi/test_array/test_array.c
@@ -13,13 +13,13 @@ napi_value TestGetElement(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
   NAPI_ASSERT(env, valuetype0 == napi_object,
-    "Wrong type of arguments. Expects an array as first argument.");
+      "Wrong type of arguments. Expects an array as first argument.");
 
   napi_valuetype valuetype1;
   NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
 
   NAPI_ASSERT(env, valuetype1 == napi_number,
-    "Wrong type of arguments. Expects an integer as second argument.");
+      "Wrong type of arguments. Expects an integer as second argument.");
 
   napi_value array = args[0];
   int32_t index;
@@ -56,13 +56,13 @@ napi_value TestHasElement(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
   NAPI_ASSERT(env, valuetype0 == napi_object,
-    "Wrong type of arguments. Expects an array as first argument.");
+      "Wrong type of arguments. Expects an array as first argument.");
 
   napi_valuetype valuetype1;
   NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
 
   NAPI_ASSERT(env, valuetype1 == napi_number,
-    "Wrong type of arguments. Expects an integer as second argument.");
+      "Wrong type of arguments. Expects an integer as second argument.");
 
   napi_value array = args[0];
   int32_t index;
@@ -94,12 +94,12 @@ napi_value TestDeleteElement(napi_env env, napi_callback_info info) {
   napi_valuetype valuetype0;
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
   NAPI_ASSERT(env, valuetype0 == napi_object,
-    "Wrong type of arguments. Expects an array as first argument.");
+      "Wrong type of arguments. Expects an array as first argument.");
 
   napi_valuetype valuetype1;
   NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
   NAPI_ASSERT(env, valuetype1 == napi_number,
-    "Wrong type of arguments. Expects an integer as second argument.");
+      "Wrong type of arguments. Expects an integer as second argument.");
 
   napi_value array = args[0];
   int32_t index;
@@ -130,7 +130,7 @@ napi_value New(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
   NAPI_ASSERT(env, valuetype0 == napi_object,
-    "Wrong type of arguments. Expects an array as first argument.");
+      "Wrong type of arguments. Expects an array as first argument.");
 
   napi_value ret;
   NAPI_CALL(env, napi_create_array(env, &ret));
@@ -158,7 +158,7 @@ napi_value NewWithLength(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
   NAPI_ASSERT(env, valuetype0 == napi_number,
-    "Wrong type of arguments. Expects an integer the first argument.");
+      "Wrong type of arguments. Expects an integer the first argument.");
 
   int32_t array_length;
   NAPI_CALL(env, napi_get_value_int32(env, args[0], &array_length));
@@ -169,7 +169,7 @@ napi_value NewWithLength(napi_env env, napi_callback_info info) {
   return ret;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("TestGetElement", TestGetElement),
     DECLARE_NAPI_PROPERTY("TestHasElement", TestHasElement),
@@ -178,8 +178,10 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("NewWithLength", NewWithLength),
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_async/test_async.cc b/test/addons-napi/test_async/test_async.cc
index 71b1c03fba0cf8..95b061fdf3892f 100644
--- a/test/addons-napi/test_async/test_async.cc
+++ b/test/addons-napi/test_async/test_async.cc
@@ -55,7 +55,7 @@ void Complete(napi_env env, napi_status status, void* data) {
   NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, c->_output, &argv[1]));
   napi_value callback;
   NAPI_CALL_RETURN_VOID(env,
-    napi_get_reference_value(env, c->_callback, &callback));
+      napi_get_reference_value(env, c->_callback, &callback));
   napi_value global;
   NAPI_CALL_RETURN_VOID(env, napi_get_global(env, &global));
 
@@ -80,7 +80,7 @@ napi_value Test(napi_env env, napi_callback_info info) {
   napi_valuetype t;
   NAPI_CALL(env, napi_typeof(env, argv[0], &t));
   NAPI_ASSERT(env, t == napi_number,
-    "Wrong first argument, integer expected.");
+      "Wrong first argument, integer expected.");
   NAPI_CALL(env, napi_typeof(env, argv[1], &t));
   NAPI_ASSERT(env, t == napi_object,
     "Wrong second argument, object expected.");
@@ -91,7 +91,7 @@ napi_value Test(napi_env env, napi_callback_info info) {
   the_carrier._output = 0;
 
   NAPI_CALL(env,
-    napi_get_value_int32(env, argv[0], &the_carrier._input));
+      napi_get_value_int32(env, argv[0], &the_carrier._input));
   NAPI_CALL(env,
     napi_create_reference(env, argv[2], 1, &the_carrier._callback));
 
@@ -100,7 +100,7 @@ napi_value Test(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_create_async_work(env, argv[1], resource_name,
     Execute, Complete, &the_carrier, &the_carrier._request));
   NAPI_CALL(env,
-    napi_queue_async_work(env, the_carrier._request));
+      napi_queue_async_work(env, the_carrier._request));
 
   return nullptr;
 }
@@ -118,7 +118,7 @@ void CancelComplete(napi_env env, napi_status status, void* data) {
     // indicate the cancel succeeded.
     napi_value callback;
     NAPI_CALL_RETURN_VOID(env,
-      napi_get_reference_value(env, c->_callback, &callback));
+        napi_get_reference_value(env, c->_callback, &callback));
     napi_value global;
     NAPI_CALL_RETURN_VOID(env, napi_get_global(env, &global));
     napi_value result;
@@ -167,20 +167,22 @@ napi_value TestCancel(napi_env env, napi_callback_info info) {
     CancelExecute, CancelComplete,
     &async_carrier[0], &async_carrier[0]._request));
   NAPI_CALL(env,
-    napi_create_reference(env, argv[0], 1, &async_carrier[0]._callback));
+      napi_create_reference(env, argv[0], 1, &async_carrier[0]._callback));
   NAPI_CALL(env, napi_queue_async_work(env, async_carrier[0]._request));
   NAPI_CALL(env, napi_cancel_async_work(env, async_carrier[0]._request));
   return nullptr;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor properties[] = {
     DECLARE_NAPI_PROPERTY("Test", Test),
     DECLARE_NAPI_PROPERTY("TestCancel", TestCancel),
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(properties) / sizeof(*properties), properties));
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(properties) / sizeof(*properties), properties));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_buffer/test_buffer.c b/test/addons-napi/test_buffer/test_buffer.c
index 0e12bedfb5602f..aafc617c7374bb 100644
--- a/test/addons-napi/test_buffer/test_buffer.c
+++ b/test/addons-napi/test_buffer/test_buffer.c
@@ -62,7 +62,7 @@ napi_value getDeleterCallCount(napi_env env, napi_callback_info info) {
 napi_value copyBuffer(napi_env env, napi_callback_info info) {
   napi_value theBuffer;
   NAPI_CALL(env, napi_create_buffer_copy(
-    env, sizeof(theText), theText, NULL, &theBuffer));
+      env, sizeof(theText), theText, NULL, &theBuffer));
   return theBuffer;
 }
 
@@ -76,8 +76,8 @@ napi_value bufferHasInstance(napi_env env, napi_callback_info info) {
   napi_valuetype theType;
   NAPI_CALL(env, napi_typeof(env, theBuffer, &theType));
   NAPI_ASSERT(env,
-            theType == napi_object,
-            "bufferHasInstance: instance is not an object");
+              theType == napi_object,
+              "bufferHasInstance: instance is not an object");
   NAPI_CALL(env, napi_is_buffer(env, theBuffer, &hasInstance));
   NAPI_ASSERT(env, hasInstance, "bufferHasInstance: instance is not a buffer");
   napi_value returnValue;
@@ -101,8 +101,8 @@ napi_value bufferInfo(napi_env env, napi_callback_info info) {
                 (void**)(&bufferData),
                 &bufferLength));
   NAPI_CALL(env, napi_get_boolean(env,
-    !strcmp(bufferData, theText) && bufferLength == sizeof(theText),
-    &returnValue));
+      !strcmp(bufferData, theText) && bufferLength == sizeof(theText),
+      &returnValue));
   return returnValue;
 }
 
@@ -119,13 +119,12 @@ napi_value staticBuffer(napi_env env, napi_callback_info info) {
   return theBuffer;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_value theValue;
 
-  NAPI_CALL_RETURN_VOID(env,
-    napi_create_string_utf8(env, theText, sizeof(theText), &theValue));
-  NAPI_CALL_RETURN_VOID(env,
-    napi_set_named_property(env, exports, "theText", theValue));
+  NAPI_CALL(env,
+      napi_create_string_utf8(env, theText, sizeof(theText), &theValue));
+  NAPI_CALL(env, napi_set_named_property(env, exports, "theText", theValue));
 
   napi_property_descriptor methods[] = {
     DECLARE_NAPI_PROPERTY("newBuffer", newBuffer),
@@ -137,8 +136,10 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("staticBuffer", staticBuffer),
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(methods) / sizeof(methods[0]), methods));
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(methods) / sizeof(methods[0]), methods));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_constructor/test_constructor.c b/test/addons-napi/test_constructor/test_constructor.c
index a991dab8533bf1..437c32e12517fc 100644
--- a/test/addons-napi/test_constructor/test_constructor.c
+++ b/test/addons-napi/test_constructor/test_constructor.c
@@ -59,9 +59,9 @@ napi_value GetStaticValue(napi_env env, napi_callback_info info) {
 }
 
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_value number;
-  NAPI_CALL_RETURN_VOID(env, napi_create_double(env, value_, &number));
+  NAPI_CALL(env, napi_create_double(env, value_, &number));
 
   napi_property_descriptor properties[] = {
     { "echo", 0, Echo, 0, 0, 0, napi_enumerable, 0 },
@@ -77,14 +77,12 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
   };
 
   napi_value cons;
-  NAPI_CALL_RETURN_VOID(env, napi_define_class(env, "MyObject", New,
-    NULL, sizeof(properties)/sizeof(*properties), properties, &cons));
+  NAPI_CALL(env, napi_define_class(env, "MyObject", New,
+      NULL, sizeof(properties)/sizeof(*properties), properties, &cons));
 
-  NAPI_CALL_RETURN_VOID(env,
-    napi_set_named_property(env, module, "exports", cons));
+  NAPI_CALL(env, napi_create_reference(env, cons, 1, &constructor_));
 
-  NAPI_CALL_RETURN_VOID(env,
-    napi_create_reference(env, cons, 1, &constructor_));
+  return cons;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_conversions/test_conversions.c b/test/addons-napi/test_conversions/test_conversions.c
index a8d526c763c9a2..54b1e3678d4ada 100644
--- a/test/addons-napi/test_conversions/test_conversions.c
+++ b/test/addons-napi/test_conversions/test_conversions.c
@@ -130,7 +130,7 @@ napi_value ToString(napi_env env, napi_callback_info info) {
   return output;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("asBool", AsBool),
     DECLARE_NAPI_PROPERTY("asInt32", AsInt32),
@@ -144,8 +144,10 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("toString", ToString),
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_dataview/test_dataview.c b/test/addons-napi/test_dataview/test_dataview.c
index 4060e4d2666c44..698ea0bf509856 100644
--- a/test/addons-napi/test_dataview/test_dataview.c
+++ b/test/addons-napi/test_dataview/test_dataview.c
@@ -37,13 +37,15 @@ napi_value CreateDataView(napi_env env, napi_callback_info info) {
   return output_dataview;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("CreateDataView", CreateDataView)
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+  NAPI_CALL(env, napi_define_properties(
       env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_env_sharing/compare_env.c b/test/addons-napi/test_env_sharing/compare_env.c
index b209c8f6d8e968..df200f2a96f986 100644
--- a/test/addons-napi/test_env_sharing/compare_env.c
+++ b/test/addons-napi/test_env_sharing/compare_env.c
@@ -14,9 +14,9 @@ napi_value compare(napi_env env, napi_callback_info info) {
   return return_value;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* context) {
-  napi_property_descriptor prop = DECLARE_NAPI_PROPERTY("exports", compare);
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(env, module, 1, &prop));
+napi_value Init(napi_env env, napi_value exports) {
+  NAPI_CALL(env, napi_create_function(env, "exports", compare, NULL, &exports));
+  return exports;
 }
 
 NAPI_MODULE(compare_env, Init)
diff --git a/test/addons-napi/test_env_sharing/store_env.c b/test/addons-napi/test_env_sharing/store_env.c
index 391f6faa27648e..c6105f348c7239 100644
--- a/test/addons-napi/test_env_sharing/store_env.c
+++ b/test/addons-napi/test_env_sharing/store_env.c
@@ -1,12 +1,10 @@
 #include <node_api.h>
 #include "../common.h"
 
-void Init(napi_env env, napi_value exports, napi_value module, void* context) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_value external;
-  NAPI_CALL_RETURN_VOID(env,
-    napi_create_external(env, env, NULL, NULL, &external));
-  NAPI_CALL_RETURN_VOID(env,
-    napi_set_named_property(env, module, "exports", external));
+  NAPI_CALL(env, napi_create_external(env, env, NULL, NULL, &external));
+  return external;
 }
 
 NAPI_MODULE(store_env, Init)
diff --git a/test/addons-napi/test_error/test_error.cc b/test/addons-napi/test_error/test_error.cc
index 29aba1f1ef62f6..4dd832d673862e 100644
--- a/test/addons-napi/test_error/test_error.cc
+++ b/test/addons-napi/test_error/test_error.cc
@@ -119,7 +119,7 @@ napi_value createTypeErrorCode(napi_env env, napi_callback_info info) {
   return result;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("checkError", checkError),
     DECLARE_NAPI_PROPERTY("throwExistingError", throwExistingError),
@@ -137,8 +137,10 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("createTypeErrorCode", createTypeErrorCode),
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_exception/test_exception.c b/test/addons-napi/test_exception/test_exception.c
index 191ac3f8ba5aec..2ab01b653becfb 100644
--- a/test/addons-napi/test_exception/test_exception.c
+++ b/test/addons-napi/test_exception/test_exception.c
@@ -45,15 +45,17 @@ napi_value wasPending(napi_env env, napi_callback_info info) {
   return result;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("returnException", returnException),
     DECLARE_NAPI_PROPERTY("allowException", allowException),
     DECLARE_NAPI_PROPERTY("wasPending", wasPending),
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_fatal/test_fatal.c b/test/addons-napi/test_fatal/test_fatal.c
index 1e8a1cf7955d18..f6cb2184a6e8e2 100644
--- a/test/addons-napi/test_fatal/test_fatal.c
+++ b/test/addons-napi/test_fatal/test_fatal.c
@@ -6,13 +6,15 @@ napi_value Test(napi_env env, napi_callback_info info) {
   return NULL;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor properties[] = {
     DECLARE_NAPI_PROPERTY("Test", Test),
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
+  NAPI_CALL(env, napi_define_properties(
       env, exports, sizeof(properties) / sizeof(*properties), properties));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_function/test_function.c b/test/addons-napi/test_function/test_function.c
index 4ce0203e7232dd..2cb25db5beaf03 100644
--- a/test/addons-napi/test_function/test_function.c
+++ b/test/addons-napi/test_function/test_function.c
@@ -12,7 +12,7 @@ napi_value Test(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
   NAPI_ASSERT(env, valuetype0 == napi_function,
-    "Wrong type of arguments. Expects a function as first argument.");
+      "Wrong type of arguments. Expects a function as first argument.");
 
   napi_value* argv = args + 1;
   argc = argc - 1;
@@ -26,10 +26,11 @@ napi_value Test(napi_env env, napi_callback_info info) {
   return result;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_value fn;
-  NAPI_CALL_RETURN_VOID(env, napi_create_function(env, NULL, Test, NULL, &fn));
-  NAPI_CALL_RETURN_VOID(env, napi_set_named_property(env, exports, "Test", fn));
+  NAPI_CALL(env, napi_create_function(env, NULL, Test, NULL, &fn));
+  NAPI_CALL(env, napi_set_named_property(env, exports, "Test", fn));
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_general/test_general.c b/test/addons-napi/test_general/test_general.c
index 048066d25c789b..5b909be7a1f1ab 100644
--- a/test/addons-napi/test_general/test_general.c
+++ b/test/addons-napi/test_general/test_general.c
@@ -92,9 +92,9 @@ napi_value createNapiError(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_get_last_error_info(env, &error_info));
 
   NAPI_ASSERT(env, error_info->error_code == status,
-    "Last error info code should match last status");
+      "Last error info code should match last status");
   NAPI_ASSERT(env, error_info->error_message,
-    "Last error info message should not be null");
+      "Last error info message should not be null");
 
   return NULL;
 }
@@ -224,7 +224,7 @@ napi_value testNapiRun(napi_env env, napi_callback_info info) {
   return result;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("testStrictEquals", testStrictEquals),
     DECLARE_NAPI_PROPERTY("testGetPrototype", testGetPrototype),
@@ -245,8 +245,10 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("testAdjustExternalMemory", testAdjustExternalMemory)
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_handle_scope/test_handle_scope.c b/test/addons-napi/test_handle_scope/test_handle_scope.c
index 6637da82316185..353a8a44031221 100644
--- a/test/addons-napi/test_handle_scope/test_handle_scope.c
+++ b/test/addons-napi/test_handle_scope/test_handle_scope.c
@@ -54,19 +54,19 @@ napi_value NewScopeWithException(napi_env env, napi_callback_info info) {
 
   argc = 1;
   NAPI_CALL(env, napi_get_cb_info(
-    env, info, &argc, &exception_function, NULL, NULL));
+      env, info, &argc, &exception_function, NULL, NULL));
 
-	status = napi_call_function(
-    env, output, exception_function, 0, NULL, NULL);
+  status = napi_call_function(
+      env, output, exception_function, 0, NULL, NULL);
   NAPI_ASSERT(env, status == napi_pending_exception,
-    "Function should have thrown.");
+      "Function should have thrown.");
 
   // Closing a handle scope should still work while an exception is pending.
   NAPI_CALL(env, napi_close_handle_scope(env, scope));
   return NULL;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor properties[] = {
     DECLARE_NAPI_PROPERTY("NewScope", NewScope),
     DECLARE_NAPI_PROPERTY("NewScopeEscape", NewScopeEscape),
@@ -74,8 +74,10 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("NewScopeWithException", NewScopeWithException),
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(properties) / sizeof(*properties), properties));
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(properties) / sizeof(*properties), properties));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_make_callback/binding.cc b/test/addons-napi/test_make_callback/binding.cc
index 987b024098598c..1ba28c0ef40b72 100644
--- a/test/addons-napi/test_make_callback/binding.cc
+++ b/test/addons-napi/test_make_callback/binding.cc
@@ -35,12 +35,11 @@ napi_value MakeCallback(napi_env env, napi_callback_info info) {
   return result;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_value fn;
-  NAPI_CALL_RETURN_VOID(env,
-    napi_create_function(env, NULL, MakeCallback, NULL, &fn));
-  NAPI_CALL_RETURN_VOID(env,
-    napi_set_named_property(env, exports, "makeCallback", fn));
+  NAPI_CALL(env, napi_create_function(env, NULL, MakeCallback, NULL, &fn));
+  NAPI_CALL(env, napi_set_named_property(env, exports, "makeCallback", fn));
+  return exports;
 }
 
 }  // namespace
diff --git a/test/addons-napi/test_make_callback_recurse/binding.cc b/test/addons-napi/test_make_callback_recurse/binding.cc
index 3f5a4c28b43524..f3c80ab103406e 100644
--- a/test/addons-napi/test_make_callback_recurse/binding.cc
+++ b/test/addons-napi/test_make_callback_recurse/binding.cc
@@ -13,20 +13,18 @@ napi_value MakeCallback(napi_env env, napi_callback_info info) {
   napi_value func = args[1];
 
   napi_make_callback(env,
-    recv, func, 0 /* argc */, nullptr /* argv */, nullptr /* result */);
+      recv, func, 0 /* argc */, nullptr /* argv */, nullptr /* result */);
 
   return recv;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_value fn;
-  NAPI_CALL_RETURN_VOID(env,
-    napi_create_function(env, NULL, MakeCallback, NULL, &fn));
-  NAPI_CALL_RETURN_VOID(env,
-    napi_set_named_property(env, exports, "makeCallback", fn));
+  NAPI_CALL(env, napi_create_function(env, NULL, MakeCallback, NULL, &fn));
+  NAPI_CALL(env, napi_set_named_property(env, exports, "makeCallback", fn));
+  return exports;
 }
 
-
 }  // namespace
 
 NAPI_MODULE(binding, Init)
diff --git a/test/addons-napi/test_number/test_number.c b/test/addons-napi/test_number/test_number.c
index 6b28afe18ff9e8..d88b1d8b23447b 100644
--- a/test/addons-napi/test_number/test_number.c
+++ b/test/addons-napi/test_number/test_number.c
@@ -12,7 +12,7 @@ napi_value Test(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
   NAPI_ASSERT(env, valuetype0 == napi_number,
-    "Wrong type of arguments. Expects a number as first argument.");
+      "Wrong type of arguments. Expects a number as first argument.");
 
   double input;
   NAPI_CALL(env, napi_get_value_double(env, args[0], &input));
@@ -34,7 +34,7 @@ napi_value TestInt32Truncation(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
   NAPI_ASSERT(env, valuetype0 == napi_number,
-    "Wrong type of arguments. Expects a number as first argument.");
+      "Wrong type of arguments. Expects a number as first argument.");
 
   int32_t input;
   NAPI_CALL(env, napi_get_value_int32(env, args[0], &input));
@@ -45,14 +45,16 @@ napi_value TestInt32Truncation(napi_env env, napi_callback_info info) {
   return output;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("Test", Test),
     DECLARE_NAPI_PROPERTY("TestInt32Truncation", TestInt32Truncation),
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_object/test_object.c b/test/addons-napi/test_object/test_object.c
index 88ac79c170f5ea..75e0ee4c30f85c 100644
--- a/test/addons-napi/test_object/test_object.c
+++ b/test/addons-napi/test_object/test_object.c
@@ -16,13 +16,13 @@ napi_value Get(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
   NAPI_ASSERT(env, valuetype0 == napi_object,
-    "Wrong type of arguments. Expects an object as first argument.");
+      "Wrong type of arguments. Expects an object as first argument.");
 
   napi_valuetype valuetype1;
   NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
 
   NAPI_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
-    "Wrong type of arguments. Expects a string or symbol as second.");
+      "Wrong type of arguments. Expects a string or symbol as second.");
 
   napi_value object = args[0];
   napi_value output;
@@ -42,13 +42,13 @@ napi_value Set(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
   NAPI_ASSERT(env, valuetype0 == napi_object,
-    "Wrong type of arguments. Expects an object as first argument.");
+      "Wrong type of arguments. Expects an object as first argument.");
 
   napi_valuetype valuetype1;
   NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
 
   NAPI_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
-    "Wrong type of arguments. Expects a string or symbol as second.");
+      "Wrong type of arguments. Expects a string or symbol as second.");
 
   NAPI_CALL(env, napi_set_property(env, args[0], args[1], args[2]));
 
@@ -69,13 +69,13 @@ napi_value Has(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
   NAPI_ASSERT(env, valuetype0 == napi_object,
-    "Wrong type of arguments. Expects an object as first argument.");
+      "Wrong type of arguments. Expects an object as first argument.");
 
   napi_valuetype valuetype1;
   NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
 
   NAPI_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
-    "Wrong type of arguments. Expects a string or symbol as second.");
+      "Wrong type of arguments. Expects a string or symbol as second.");
 
   bool has_property;
   NAPI_CALL(env, napi_has_property(env, args[0], args[1], &has_property));
@@ -97,7 +97,7 @@ napi_value HasOwn(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
   NAPI_ASSERT(env, valuetype0 == napi_object,
-    "Wrong type of arguments. Expects an object as first argument.");
+      "Wrong type of arguments. Expects an object as first argument.");
 
   // napi_valuetype valuetype1;
   // NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
@@ -124,12 +124,12 @@ napi_value Delete(napi_env env, napi_callback_info info) {
   napi_valuetype valuetype0;
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
   NAPI_ASSERT(env, valuetype0 == napi_object,
-    "Wrong type of arguments. Expects an object as first argument.");
+      "Wrong type of arguments. Expects an object as first argument.");
 
   napi_valuetype valuetype1;
   NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
   NAPI_ASSERT(env, valuetype1 == napi_string || valuetype1 == napi_symbol,
-    "Wrong type of arguments. Expects a string or symbol as second.");
+      "Wrong type of arguments. Expects a string or symbol as second.");
 
   bool result;
   napi_value ret;
@@ -169,7 +169,7 @@ napi_value Inflate(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
   NAPI_ASSERT(env, valuetype0 == napi_object,
-    "Wrong type of arguments. Expects an object as first argument.");
+      "Wrong type of arguments. Expects an object as first argument.");
 
   napi_value obj = args[0];
   napi_value propertynames;
@@ -219,7 +219,7 @@ napi_value Unwrap(napi_env env, napi_callback_info info) {
   return result;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("Get", Get),
     DECLARE_NAPI_PROPERTY("Set", Set),
@@ -232,8 +232,10 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("Unwrap", Unwrap),
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_promise/test_promise.c b/test/addons-napi/test_promise/test_promise.c
index dc617f4592e520..0ec3e0c3d84379 100644
--- a/test/addons-napi/test_promise/test_promise.c
+++ b/test/addons-napi/test_promise/test_promise.c
@@ -46,15 +46,17 @@ napi_value isPromise(napi_env env, napi_callback_info info) {
   return result;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("createPromise", createPromise),
     DECLARE_NAPI_PROPERTY("concludeCurrentPromise", concludeCurrentPromise),
     DECLARE_NAPI_PROPERTY("isPromise", isPromise),
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_properties/test_properties.c b/test/addons-napi/test_properties/test_properties.c
index 3f4f0a6bcbba96..da516b6b5acd52 100644
--- a/test/addons-napi/test_properties/test_properties.c
+++ b/test/addons-napi/test_properties/test_properties.c
@@ -48,7 +48,7 @@ napi_value HasNamedProperty(napi_env env, napi_callback_info info) {
   char buffer[128];
   size_t copied;
   NAPI_CALL(env,
-    napi_get_value_string_utf8(env, args[1], buffer, sizeof(buffer), &copied));
+      napi_get_value_string_utf8(env, args[1], buffer, sizeof(buffer), &copied));
 
   // do the check and create the boolean return value
   bool value;
@@ -59,25 +59,25 @@ napi_value HasNamedProperty(napi_env env, napi_callback_info info) {
   return result;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_value number;
-  NAPI_CALL_RETURN_VOID(env, napi_create_double(env, value_, &number));
+  NAPI_CALL(env, napi_create_double(env, value_, &number));
 
   napi_value name_value;
-  NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env,
-                                                     "NameKeyValue",
-                                                     -1,
-                                                     &name_value));
+  NAPI_CALL(env, napi_create_string_utf8(env,
+                                         "NameKeyValue",
+                                         -1,
+                                         &name_value));
 
   napi_value symbol_description;
   napi_value name_symbol;
-  NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(env,
-                                                     "NameKeySymbol",
-                                                      -1,
-                                                     &symbol_description));
-  NAPI_CALL_RETURN_VOID(env, napi_create_symbol(env,
-                                                symbol_description,
-                                                &name_symbol));
+  NAPI_CALL(env, napi_create_string_utf8(env,
+                                         "NameKeySymbol",
+                                         -1,
+                                         &symbol_description));
+  NAPI_CALL(env, napi_create_symbol(env,
+                                    symbol_description,
+                                    &name_symbol));
 
   napi_property_descriptor properties[] = {
     { "echo", 0, Echo, 0, 0, 0, napi_enumerable, 0 },
@@ -93,8 +93,10 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     { "hasNamedProperty", 0, HasNamedProperty, 0, 0, 0, napi_default, 0 },
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(properties) / sizeof(*properties), properties));
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(properties) / sizeof(*properties), properties));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_reference/test_reference.c b/test/addons-napi/test_reference/test_reference.c
index b16e10d70361b5..9f25eddb313bef 100644
--- a/test/addons-napi/test_reference/test_reference.c
+++ b/test/addons-napi/test_reference/test_reference.c
@@ -22,11 +22,11 @@ napi_value CreateExternal(napi_env env, napi_callback_info info) {
 
   napi_value result;
   NAPI_CALL(env,
-    napi_create_external(env,
-                         data,
-                         NULL, /* finalize_cb */
-                         NULL, /* finalize_hint */
-                         &result));
+      napi_create_external(env,
+                           data,
+                           NULL, /* finalize_cb */
+                           NULL, /* finalize_hint */
+                           &result));
 
   finalize_count = 0;
   return result;
@@ -38,11 +38,11 @@ napi_value CreateExternalWithFinalize(napi_env env, napi_callback_info info) {
 
   napi_value result;
   NAPI_CALL(env,
-    napi_create_external(env,
-                         data,
-                         FinalizeExternal,
-                         NULL, /* finalize_hint */
-                         &result));
+      napi_create_external(env,
+                           data,
+                           FinalizeExternal,
+                           NULL, /* finalize_hint */
+                           &result));
 
   finalize_count = 0;
   return result;
@@ -64,14 +64,14 @@ napi_value CheckExternal(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_get_value_external(env, arg, &data));
 
   NAPI_ASSERT(env, data != NULL && *(int*)data == test_value,
-    "An external data value of 1 was expected.");
+      "An external data value of 1 was expected.");
 
   return NULL;
 }
 
 napi_value CreateReference(napi_env env, napi_callback_info info) {
   NAPI_ASSERT(env, test_reference == NULL,
-    "The test allows only one reference at a time.");
+      "The test allows only one reference at a time.");
 
   size_t argc = 2;
   napi_value args[2];
@@ -82,17 +82,17 @@ napi_value CreateReference(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_get_value_uint32(env, args[1], &initial_refcount));
 
   NAPI_CALL(env,
-    napi_create_reference(env, args[0], initial_refcount, &test_reference));
+      napi_create_reference(env, args[0], initial_refcount, &test_reference));
 
   NAPI_ASSERT(env, test_reference != NULL,
-    "A reference should have been created.");
+      "A reference should have been created.");
 
   return NULL;
 }
 
 napi_value DeleteReference(napi_env env, napi_callback_info info) {
   NAPI_ASSERT(env, test_reference != NULL,
-    "A reference must have been created.");
+      "A reference must have been created.");
 
   NAPI_CALL(env, napi_delete_reference(env, test_reference));
   test_reference = NULL;
@@ -101,7 +101,7 @@ napi_value DeleteReference(napi_env env, napi_callback_info info) {
 
 napi_value IncrementRefcount(napi_env env, napi_callback_info info) {
   NAPI_ASSERT(env, test_reference != NULL,
-    "A reference must have been created.");
+      "A reference must have been created.");
 
   uint32_t refcount;
   NAPI_CALL(env, napi_reference_ref(env, test_reference, &refcount));
@@ -113,7 +113,7 @@ napi_value IncrementRefcount(napi_env env, napi_callback_info info) {
 
 napi_value DecrementRefcount(napi_env env, napi_callback_info info) {
   NAPI_ASSERT(env, test_reference != NULL,
-    "A reference must have been created.");
+      "A reference must have been created.");
 
   uint32_t refcount;
   NAPI_CALL(env, napi_reference_unref(env, test_reference, &refcount));
@@ -125,19 +125,19 @@ napi_value DecrementRefcount(napi_env env, napi_callback_info info) {
 
 napi_value GetReferenceValue(napi_env env, napi_callback_info info) {
   NAPI_ASSERT(env, test_reference != NULL,
-    "A reference must have been created.");
+      "A reference must have been created.");
 
   napi_value result;
   NAPI_CALL(env, napi_get_reference_value(env, test_reference, &result));
   return result;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_GETTER("finalizeCount", GetFinalizeCount),
     DECLARE_NAPI_PROPERTY("createExternal", CreateExternal),
     DECLARE_NAPI_PROPERTY("createExternalWithFinalize",
-      CreateExternalWithFinalize),
+        CreateExternalWithFinalize),
     DECLARE_NAPI_PROPERTY("checkExternal", CheckExternal),
     DECLARE_NAPI_PROPERTY("createReference", CreateReference),
     DECLARE_NAPI_PROPERTY("deleteReference", DeleteReference),
@@ -146,8 +146,10 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_GETTER("referenceValue", GetReferenceValue),
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_string/test_string.c b/test/addons-napi/test_string/test_string.c
index ec80e2c7b57fa8..a588b6a1b4e290 100644
--- a/test/addons-napi/test_string/test_string.c
+++ b/test/addons-napi/test_string/test_string.c
@@ -12,14 +12,14 @@ napi_value TestLatin1(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
   NAPI_ASSERT(env, valuetype == napi_string,
-    "Wrong type of argment. Expects a string.");
+      "Wrong type of argment. Expects a string.");
 
   char buffer[128];
   size_t buffer_size = 128;
   size_t copied;
 
   NAPI_CALL(env,
-    napi_get_value_string_latin1(env, args[0], buffer, buffer_size, &copied));
+      napi_get_value_string_latin1(env, args[0], buffer, buffer_size, &copied));
 
   napi_value output;
   NAPI_CALL(env, napi_create_string_latin1(env, buffer, copied, &output));
@@ -38,14 +38,14 @@ napi_value TestUtf8(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
   NAPI_ASSERT(env, valuetype == napi_string,
-    "Wrong type of argment. Expects a string.");
+      "Wrong type of argment. Expects a string.");
 
   char buffer[128];
   size_t buffer_size = 128;
   size_t copied;
 
   NAPI_CALL(env,
-    napi_get_value_string_utf8(env, args[0], buffer, buffer_size, &copied));
+      napi_get_value_string_utf8(env, args[0], buffer, buffer_size, &copied));
 
   napi_value output;
   NAPI_CALL(env, napi_create_string_utf8(env, buffer, copied, &output));
@@ -64,14 +64,14 @@ napi_value TestUtf16(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
   NAPI_ASSERT(env, valuetype == napi_string,
-    "Wrong type of argment. Expects a string.");
+      "Wrong type of argment. Expects a string.");
 
   char16_t buffer[128];
   size_t buffer_size = 128;
   size_t copied;
 
   NAPI_CALL(env,
-    napi_get_value_string_utf16(env, args[0], buffer, buffer_size, &copied));
+      napi_get_value_string_utf16(env, args[0], buffer, buffer_size, &copied));
 
   napi_value output;
   NAPI_CALL(env, napi_create_string_utf16(env, buffer, copied, &output));
@@ -90,14 +90,14 @@ napi_value TestLatin1Insufficient(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
   NAPI_ASSERT(env, valuetype == napi_string,
-    "Wrong type of argment. Expects a string.");
+      "Wrong type of argment. Expects a string.");
 
   char buffer[4];
   size_t buffer_size = 4;
   size_t copied;
 
   NAPI_CALL(env,
-    napi_get_value_string_latin1(env, args[0], buffer, buffer_size, &copied));
+      napi_get_value_string_latin1(env, args[0], buffer, buffer_size, &copied));
 
   napi_value output;
   NAPI_CALL(env, napi_create_string_latin1(env, buffer, copied, &output));
@@ -116,14 +116,14 @@ napi_value TestUtf8Insufficient(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
   NAPI_ASSERT(env, valuetype == napi_string,
-    "Wrong type of argment. Expects a string.");
+      "Wrong type of argment. Expects a string.");
 
   char buffer[4];
   size_t buffer_size = 4;
   size_t copied;
 
   NAPI_CALL(env,
-    napi_get_value_string_utf8(env, args[0], buffer, buffer_size, &copied));
+      napi_get_value_string_utf8(env, args[0], buffer, buffer_size, &copied));
 
   napi_value output;
   NAPI_CALL(env, napi_create_string_utf8(env, buffer, copied, &output));
@@ -142,14 +142,14 @@ napi_value TestUtf16Insufficient(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
   NAPI_ASSERT(env, valuetype == napi_string,
-    "Wrong type of argment. Expects a string.");
+      "Wrong type of argment. Expects a string.");
 
   char16_t buffer[4];
   size_t buffer_size = 4;
   size_t copied;
 
   NAPI_CALL(env,
-    napi_get_value_string_utf16(env, args[0], buffer, buffer_size, &copied));
+      napi_get_value_string_utf16(env, args[0], buffer, buffer_size, &copied));
 
   napi_value output;
   NAPI_CALL(env, napi_create_string_utf16(env, buffer, copied, &output));
@@ -168,7 +168,7 @@ napi_value Utf16Length(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
   NAPI_ASSERT(env, valuetype == napi_string,
-    "Wrong type of argment. Expects a string.");
+      "Wrong type of argment. Expects a string.");
 
   size_t length;
   NAPI_CALL(env, napi_get_value_string_utf16(env, args[0], NULL, 0, &length));
@@ -190,7 +190,7 @@ napi_value Utf8Length(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
   NAPI_ASSERT(env, valuetype == napi_string,
-    "Wrong type of argment. Expects a string.");
+      "Wrong type of argment. Expects a string.");
 
   size_t length;
   NAPI_CALL(env, napi_get_value_string_utf8(env, args[0], NULL, 0, &length));
@@ -201,7 +201,7 @@ napi_value Utf8Length(napi_env env, napi_callback_info info) {
   return output;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor properties[] = {
     DECLARE_NAPI_PROPERTY("TestLatin1", TestLatin1),
     DECLARE_NAPI_PROPERTY("TestLatin1Insufficient", TestLatin1Insufficient),
@@ -213,8 +213,10 @@ void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
     DECLARE_NAPI_PROPERTY("Utf8Length", Utf8Length),
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(properties) / sizeof(*properties), properties));
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(properties) / sizeof(*properties), properties));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_symbol/test_symbol.c b/test/addons-napi/test_symbol/test_symbol.c
index f85567c071e256..acb1c7f715409a 100644
--- a/test/addons-napi/test_symbol/test_symbol.c
+++ b/test/addons-napi/test_symbol/test_symbol.c
@@ -12,13 +12,13 @@ napi_value Test(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
   NAPI_ASSERT(env, valuetype == napi_symbol,
-    "Wrong type of argments. Expects a symbol.");
+      "Wrong type of argments. Expects a symbol.");
 
   char buffer[128];
   size_t buffer_size = 128;
 
   NAPI_CALL(env, napi_get_value_string_utf8(
-    env, args[0], buffer, buffer_size, NULL));
+      env, args[0], buffer, buffer_size, NULL));
 
   napi_value output;
   NAPI_CALL(env, napi_create_string_utf8(env, buffer, buffer_size, &output));
@@ -37,7 +37,7 @@ napi_value New(napi_env env, napi_callback_info info) {
     NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
     NAPI_ASSERT(env, valuetype == napi_string,
-      "Wrong type of arguments. Expects a string.");
+        "Wrong type of arguments. Expects a string.");
 
     description = args[0];
   }
@@ -48,13 +48,15 @@ napi_value New(napi_env env, napi_callback_info info) {
   return symbol;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor properties[] = {
     DECLARE_NAPI_PROPERTY("New", New),
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(properties) / sizeof(*properties), properties));
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(properties) / sizeof(*properties), properties));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_typedarray/test_typedarray.c b/test/addons-napi/test_typedarray/test_typedarray.c
index ffc118681bad9e..93995d450c440b 100644
--- a/test/addons-napi/test_typedarray/test_typedarray.c
+++ b/test/addons-napi/test_typedarray/test_typedarray.c
@@ -13,20 +13,20 @@ napi_value Multiply(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
   NAPI_ASSERT(env, valuetype0 == napi_object,
-    "Wrong type of argments. Expects a typed array as first argument.");
+      "Wrong type of argments. Expects a typed array as first argument.");
 
   napi_value input_array = args[0];
   bool is_typedarray;
   NAPI_CALL(env, napi_is_typedarray(env, input_array, &is_typedarray));
 
   NAPI_ASSERT(env, is_typedarray,
-    "Wrong type of argments. Expects a typed array as first argument.");
+      "Wrong type of argments. Expects a typed array as first argument.");
 
   napi_valuetype valuetype1;
   NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
 
   NAPI_ASSERT(env, valuetype1 == napi_number,
-    "Wrong type of argments. Expects a number as second argument.");
+      "Wrong type of argments. Expects a number as second argument.");
 
   double multiplier;
   NAPI_CALL(env, napi_get_value_double(env, args[1], &multiplier));
@@ -36,17 +36,17 @@ napi_value Multiply(napi_env env, napi_callback_info info) {
   size_t byte_offset;
   size_t i, length;
   NAPI_CALL(env, napi_get_typedarray_info(
-    env, input_array, &type, &length, NULL, &input_buffer, &byte_offset));
+      env, input_array, &type, &length, NULL, &input_buffer, &byte_offset));
 
   void* data;
   size_t byte_length;
   NAPI_CALL(env, napi_get_arraybuffer_info(
-    env, input_buffer, &data, &byte_length));
+      env, input_buffer, &data, &byte_length));
 
   napi_value output_buffer;
   void* output_ptr = NULL;
   NAPI_CALL(env, napi_create_arraybuffer(
-    env, byte_length, &output_ptr, &output_buffer));
+      env, byte_length, &output_ptr, &output_buffer));
 
   napi_value output_array;
   NAPI_CALL(env, napi_create_typedarray(
@@ -65,7 +65,8 @@ napi_value Multiply(napi_env env, napi_callback_info info) {
       output_doubles[i] = input_doubles[i] * multiplier;
     }
   } else {
-    napi_throw_error(env, NULL, "Typed array was of a type not expected by test.");
+    napi_throw_error(env, NULL,
+        "Typed array was of a type not expected by test.");
     return NULL;
   }
 
@@ -77,20 +78,20 @@ napi_value External(napi_env env, napi_callback_info info) {
 
   napi_value output_buffer;
   NAPI_CALL(env, napi_create_external_arraybuffer(
-    env,
-    externalData,
-    sizeof(externalData),
-    NULL,  // finalize_callback
-    NULL,  // finalize_hint
-    &output_buffer));
+      env,
+      externalData,
+      sizeof(externalData),
+      NULL,  // finalize_callback
+      NULL,  // finalize_hint
+      &output_buffer));
 
   napi_value output_array;
   NAPI_CALL(env, napi_create_typedarray(env,
-    napi_int8_array,
-    sizeof(externalData) / sizeof(int8_t),
-    output_buffer,
-    0,
-    &output_array));
+      napi_int8_array,
+      sizeof(externalData) / sizeof(int8_t),
+      output_buffer,
+      0,
+      &output_array));
 
   return output_array;
 }
@@ -107,33 +108,33 @@ napi_value CreateTypedArray(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, input_array, &valuetype0));
 
   NAPI_ASSERT(env, valuetype0 == napi_object,
-    "Wrong type of argments. Expects a typed array as first argument.");
+      "Wrong type of argments. Expects a typed array as first argument.");
 
   bool is_typedarray;
   NAPI_CALL(env, napi_is_typedarray(env, input_array, &is_typedarray));
 
   NAPI_ASSERT(env, is_typedarray,
-    "Wrong type of argments. Expects a typed array as first argument.");
+      "Wrong type of argments. Expects a typed array as first argument.");
 
   napi_valuetype valuetype1;
   napi_value input_buffer = args[1];
   NAPI_CALL(env, napi_typeof(env, input_buffer, &valuetype1));
 
   NAPI_ASSERT(env, valuetype1 == napi_object,
-    "Wrong type of argments. Expects an array buffer as second argument.");
+      "Wrong type of argments. Expects an array buffer as second argument.");
 
   bool is_arraybuffer;
   NAPI_CALL(env, napi_is_arraybuffer(env, input_buffer, &is_arraybuffer));
 
   NAPI_ASSERT(env, is_arraybuffer,
-    "Wrong type of argments. Expects an array buffer as second argument.");
+      "Wrong type of argments. Expects an array buffer as second argument.");
 
   napi_typedarray_type type;
   napi_value in_array_buffer;
   size_t byte_offset;
   size_t length;
   NAPI_CALL(env, napi_get_typedarray_info(
-    env, input_array, &type, &length, NULL, &in_array_buffer, &byte_offset));
+      env, input_array, &type, &length, NULL, &in_array_buffer, &byte_offset));
 
   napi_value output_array;
   NAPI_CALL(env, napi_create_typedarray(
@@ -142,15 +143,17 @@ napi_value CreateTypedArray(napi_env env, napi_callback_info info) {
   return output_array;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("Multiply", Multiply),
     DECLARE_NAPI_PROPERTY("External", External),
     DECLARE_NAPI_PROPERTY("CreateTypedArray", CreateTypedArray),
   };
 
-  NAPI_CALL_RETURN_VOID(env, napi_define_properties(
-    env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)

From edfbc5b634f0ffcaa9eb7c0cf35b5ae0167139f1 Mon Sep 17 00:00:00 2001
From: Jason Ginchereau <jasongin@microsoft.com>
Date: Sat, 26 Aug 2017 15:44:43 -0700
Subject: [PATCH 105/183] n-api: Context for custom async operations

 - Add napi_async_context opaque pointer type.
   (If needed, we could later add APIs for getting the async IDs
   out of this context.)
 - Add napi_async_init() and napi_async_destroy() APIs.
 - Add async_context parameter to napi_make_callback().
 - Add code and checks to test_make_callback to validate async context
   APIs by checking async hooks are called with correct context.
 - Update API documentation.

PR-URL: https://github.com/nodejs/node/pull/15189
Fixes: https://github.com/nodejs/node/issues/13254
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 doc/api/n-api.md                              | 214 +++++++++++-------
 src/node_api.cc                               |  61 ++++-
 src/node_api.h                                |  24 +-
 src/node_api_backport.cc                      |  20 ++
 src/node_api_backport.h                       |  15 ++
 src/node_api_types.h                          |   1 +
 .../addons-napi/test_make_callback/binding.cc |  12 +-
 test/addons-napi/test_make_callback/test.js   |   1 -
 .../test_make_callback_recurse/binding.cc     |   4 +-
 9 files changed, 256 insertions(+), 96 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 7d61dc055048e2..1d9b405c78a07e 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -41,7 +41,8 @@ The documentation for N-API is structured as follows:
 * [Working with JavaScript Properties][]
 * [Working with JavaScript Functions][]
 * [Object Wrap][]
-* [Asynchronous Operations][]
+* [Simple Asynchronous Operations][]
+* [Custom Asynchronous Operations][]
 * [Promises][]
 * [Script Execution][]
 
@@ -264,7 +265,7 @@ It is intended only for logging purposes.
 added: v8.0.0
 -->
 ```C
-NAPI_EXTERN napi_status
+napi_status
 napi_get_last_error_info(napi_env env,
                          const napi_extended_error_info** result);
 ```
@@ -515,8 +516,8 @@ This API returns a JavaScript RangeError with the text provided.
 added: v8.0.0
 -->
 ```C
-NAPI_EXTERN napi_status napi_get_and_clear_last_exception(napi_env env,
-                                                          napi_value* result);
+napi_status napi_get_and_clear_last_exception(napi_env env,
+                                              napi_value* result);
 ```
 
 - `[in] env`: The environment that the API is invoked under.
@@ -531,7 +532,7 @@ This API returns true if an exception is pending.
 added: v8.0.0
 -->
 ```C
-NAPI_EXTERN napi_status napi_is_exception_pending(napi_env env, bool* result);
+napi_status napi_is_exception_pending(napi_env env, bool* result);
 ```
 
 - `[in] env`: The environment that the API is invoked under.
@@ -551,7 +552,7 @@ thrown to immediately terminate the process.
 added: REPLACEME
 -->
 ```C
-NAPI_EXTERN NAPI_NO_RETURN void napi_fatal_error(const char* location, const char* message);
+NAPI_NO_RETURN void napi_fatal_error(const char* location, const char* message);
 ```
 
 - `[in] location`: Optional location at which the error occurred.
@@ -718,10 +719,10 @@ reverse order from which they were created.
 added: v8.0.0
 -->
 ```C
-NAPI_EXTERN napi_status napi_escape_handle(napi_env env,
-                                           napi_escapable_handle_scope scope,
-                                           napi_value escapee,
-                                           napi_value* result);
+napi_status napi_escape_handle(napi_env env,
+                               napi_escapable_handle_scope scope,
+                               napi_value escapee,
+                               napi_value* result);
 ```
 
 - `[in] env`: The environment that the API is invoked under.
@@ -1478,10 +1479,10 @@ of the ECMAScript Language Specification.
 added: v8.0.0
 -->
 ```C
-NAPI_EXTERN napi_status napi_create_string_latin1(napi_env env,
-                                                  const char* str,
-                                                  size_t length,
-                                                  napi_value* result);
+napi_status napi_create_string_latin1(napi_env env,
+                                      const char* str,
+                                      size_t length,
+                                      napi_value* result);
 ```
 
 - `[in] env`: The environment that the API is invoked under.
@@ -1811,11 +1812,11 @@ JavaScript Number
 added: v8.0.0
 -->
 ```C
-NAPI_EXTERN napi_status napi_get_value_string_latin1(napi_env env,
-                                                     napi_value value,
-                                                     char* buf,
-                                                     size_t bufsize,
-                                                     size_t* result)
+napi_status napi_get_value_string_latin1(napi_env env,
+                                         napi_value value,
+                                         char* buf,
+                                         size_t bufsize,
+                                         size_t* result)
 ```
 
 - `[in] env`: The environment that the API is invoked under.
@@ -2790,8 +2791,8 @@ in as arguments to the function.
 Returns `napi_ok` if the API succeeded.
 
 This method allows a JavaScript function object to be called from a native
-add-on. This is an primary mechanism of calling back *from* the add-on's
-native code *into* JavaScript. For special cases like calling into JavaScript
+add-on. This is the primary mechanism of calling back *from* the add-on's
+native code *into* JavaScript. For the special case of calling into JavaScript
 after an async operation, see [`napi_make_callback`][].
 
 A sample use case might look as follows. Consider the following JavaScript
@@ -3003,39 +3004,6 @@ status = napi_new_instance(env, constructor, argc, argv, &value);
 
 Returns `napi_ok` if the API succeeded.
 
-### *napi_make_callback*
-<!-- YAML
-added: v8.0.0
--->
-```C
-napi_status napi_make_callback(napi_env env,
-                               napi_value recv,
-                               napi_value func,
-                               int argc,
-                               const napi_value* argv,
-                               napi_value* result)
-```
-
-- `[in] env`: The environment that the API is invoked under.
-- `[in] recv`: The `this` object passed to the called function.
-- `[in] func`: `napi_value` representing the JavaScript function
-to be invoked.
-- `[in] argc`: The count of elements in the `argv` array.
-- `[in] argv`: Array of JavaScript values as `napi_value`
-representing the arguments to the function.
-- `[out] result`: `napi_value` representing the JavaScript object returned.
-
-Returns `napi_ok` if the API succeeded.
-
-This method allows a JavaScript function object to be called from a native
-add-on. This API is similar to `napi_call_function`. However, it is used to call
-*from* native code back *into* JavaScript *after* returning from an async
-operation (when there is no other script on the stack). It is a fairly simple
-wrapper around `node::MakeCallback`.
-
-For an example on how to use `napi_make_callback`, see the section on
-[Asynchronous Operations][].
-
 ## Object Wrap
 
 N-API offers a way to "wrap" C++ classes and instances so that the class
@@ -3214,7 +3182,7 @@ restoring the JavaScript object's prototype chain. If a finalize callback was
 associated with the wrapping, it will no longer be called when the JavaScript
 object becomes garbage-collected.
 
-## Asynchronous Operations
+## Simple Asynchronous Operations
 
 Addon modules often need to leverage async helpers from libuv as part of their
 implementation. This allows them to schedule work to be executed asynchronously
@@ -3250,8 +3218,8 @@ Once created the async worker can be queued
 for execution using the [`napi_queue_async_work`][] function:
 
 ```C
-NAPI_EXTERN napi_status napi_queue_async_work(napi_env env,
-                                              napi_async_work work);
+napi_status napi_queue_async_work(napi_env env,
+                                  napi_async_work work);
 ```
 
 [`napi_cancel_async_work`][] can be used if  the work needs
@@ -3271,7 +3239,6 @@ changes:
     description: Added `async_resource` and `async_resource_name` parameters.
 -->
 ```C
-NAPI_EXTERN
 napi_status napi_create_async_work(napi_env env,
                                    napi_value async_resource,
                                    napi_value async_resource_name,
@@ -3314,8 +3281,8 @@ for more information.
 added: v8.0.0
 -->
 ```C
-NAPI_EXTERN napi_status napi_delete_async_work(napi_env env,
-                                               napi_async_work work);
+napi_status napi_delete_async_work(napi_env env,
+                                   napi_async_work work);
 ```
 
 - `[in] env`: The environment that the API is invoked under.
@@ -3330,8 +3297,8 @@ This API frees a previously allocated work object.
 added: v8.0.0
 -->
 ```C
-NAPI_EXTERN napi_status napi_queue_async_work(napi_env env,
-                                              napi_async_work work);
+napi_status napi_queue_async_work(napi_env env,
+                                  napi_async_work work);
 ```
 
 - `[in] env`: The environment that the API is invoked under.
@@ -3347,8 +3314,8 @@ for execution.
 added: v8.0.0
 -->
 ```C
-NAPI_EXTERN napi_status napi_cancel_async_work(napi_env env,
-                                               napi_async_work work);
+napi_status napi_cancel_async_work(napi_env env,
+                                   napi_async_work work);
 ```
 
 - `[in] env`: The environment that the API is invoked under.
@@ -3363,6 +3330,93 @@ the `complete` callback will be invoked with a status value of
 `napi_cancelled`. The work should not be deleted before the `complete`
 callback invocation, even if it has been successfully cancelled.
 
+## Custom Asynchronous Operations
+The simple asynchronous work APIs above may not be appropriate for every
+scenario, because with those the async execution still happens on the main
+event loop. When using any other async mechanism, the following APIs are
+necessary to ensure an async operation is properly tracked by the runtime.
+
+### *napi_async_init**
+<!-- YAML
+added: REPLACEME
+-->
+```C
+napi_status napi_async_init(napi_env env,
+                            napi_value async_resource,
+                            napi_value async_resource_name,
+                            napi_async_context* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] async_resource`: An optional object associated with the async work
+  that will be passed to possible `async_hooks` [`init` hooks][].
+- `[in] async_resource_name`: Required identifier for the kind of resource
+  that is being provided for diagnostic information exposed by the
+  `async_hooks` API.
+- `[out] result`: The initialized async context.
+
+Returns `napi_ok` if the API succeeded.
+
+### *napi_async_destroy**
+<!-- YAML
+added: REPLACEME
+-->
+```C
+napi_status napi_async_destroy(napi_env env,
+                               napi_async_context async_context);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] async_context`: The async context to be destroyed.
+
+Returns `napi_ok` if the API succeeded.
+
+### *napi_make_callback*
+<!-- YAML
+added: v8.0.0
+changes:
+  - version: REPLACEME
+    description: Added `async_context` parameter.
+-->
+```C
+napi_status napi_make_callback(napi_env env,
+                               napi_async_context async_context,
+                               napi_value recv,
+                               napi_value func,
+                               int argc,
+                               const napi_value* argv,
+                               napi_value* result)
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] async_context`: Context for the async operation that is
+   invoking the callback. This should normally be a value previously
+   obtained from [`napi_async_init`][]. However `NULL` is also allowed,
+   which indicates the current async context (if any) is to be used
+   for the callback.
+- `[in] recv`: The `this` object passed to the called function.
+- `[in] func`: `napi_value` representing the JavaScript function
+to be invoked.
+- `[in] argc`: The count of elements in the `argv` array.
+- `[in] argv`: Array of JavaScript values as `napi_value`
+representing the arguments to the function.
+- `[out] result`: `napi_value` representing the JavaScript object returned.
+
+Returns `napi_ok` if the API succeeded.
+
+This method allows a JavaScript function object to be called from a native
+add-on. This API is similar to `napi_call_function`. However, it is used to call
+*from* native code back *into* JavaScript *after* returning from an async
+operation (when there is no other script on the stack). It is a fairly simple
+wrapper around `node::MakeCallback`.
+
+Note it is *not* necessary to use `napi_make_callback` from within a
+`napi_async_complete_callback`; in that situation the callback's async
+context has already been set up, so a direct call to `napi_call_function`
+is sufficient and appropriate. Use of the `napi_make_callback` function
+may be required when implementing custom async behavior that does not use
+`napi_create_async_work`.
+
 ## Version Management
 
 ### napi_get_node_version
@@ -3378,7 +3432,6 @@ typedef struct {
   const char* release;
 } napi_node_version;
 
-NAPI_EXTERN
 napi_status napi_get_node_version(napi_env env,
                                   const napi_node_version** version);
 ```
@@ -3399,8 +3452,8 @@ The returned buffer is statically allocated and does not need to be freed.
 added: REPLACEME
 -->
 ```C
-NAPI_EXTERN napi_status napi_get_version(napi_env env,
-                                         uint32_t* result);
+napi_status napi_get_version(napi_env env,
+                             uint32_t* result);
 ```
 
 - `[in] env`: The environment that the API is invoked under.
@@ -3508,9 +3561,9 @@ deferred = NULL;
 added: REPLACEME
 -->
 ```C
-NAPI_EXTERN napi_status napi_create_promise(napi_env env,
-                                            napi_deferred* deferred,
-                                            napi_value* promise);
+napi_status napi_create_promise(napi_env env,
+                                napi_deferred* deferred,
+                                napi_value* promise);
 ```
 
 - `[in] env`: The environment that the API is invoked under.
@@ -3528,9 +3581,9 @@ This API creates a deferred object and a JavaScript promise.
 added: REPLACEME
 -->
 ```C
-NAPI_EXTERN napi_status napi_resolve_deferred(napi_env env,
-                                              napi_deferred deferred,
-                                              napi_value resolution);
+napi_status napi_resolve_deferred(napi_env env,
+                                  napi_deferred deferred,
+                                  napi_value resolution);
 ```
 
 - `[in] env`: The environment that the API is invoked under.
@@ -3551,9 +3604,9 @@ The deferred object is freed upon successful completion.
 added: REPLACEME
 -->
 ```C
-NAPI_EXTERN napi_status napi_reject_deferred(napi_env env,
-                                             napi_deferred deferred,
-                                             napi_value rejection);
+napi_status napi_reject_deferred(napi_env env,
+                                 napi_deferred deferred,
+                                 napi_value rejection);
 ```
 
 - `[in] env`: The environment that the API is invoked under.
@@ -3574,9 +3627,9 @@ The deferred object is freed upon successful completion.
 added: REPLACEME
 -->
 ```C
-NAPI_EXTERN napi_status napi_is_promise(napi_env env,
-                                        napi_value promise,
-                                        bool* is_promise);
+napi_status napi_is_promise(napi_env env,
+                            napi_value promise,
+                            bool* is_promise);
 ```
 
 - `[in] env`: The environment that the API is invoked under.
@@ -3604,7 +3657,8 @@ NAPI_EXTERN napi_status napi_run_script(napi_env env,
 - `[out] result`: The value resulting from having executed the script.
 
 [Promises]: #n_api_promises
-[Asynchronous Operations]: #n_api_asynchronous_operations
+[Simple Asynchronous Operations]: #n_api_asynchronous_operations
+[Custom Asynchronous Operations]: #n_api_custom_asynchronous_operations
 [Basic N-API Data Types]: #n_api_basic_n_api_data_types
 [ECMAScript Language Specification]: https://tc39.github.io/ecma262/
 [Error Handling]: #n_api_error_handling
diff --git a/src/node_api.cc b/src/node_api.cc
index 5efb6b4f549e6a..246b3fd8085a41 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -2770,7 +2770,52 @@ napi_status napi_instanceof(napi_env env,
   return GET_RETURN_STATUS(env);
 }
 
+napi_status napi_async_init(napi_env env,
+                            napi_value async_resource,
+                            napi_value async_resource_name,
+                            napi_async_context* result) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, async_resource_name);
+  CHECK_ARG(env, result);
+
+  v8::Isolate* isolate = env->isolate;
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+  v8::Local<v8::Object> v8_resource;
+  if (async_resource != nullptr) {
+    CHECK_TO_OBJECT(env, context, v8_resource, async_resource);
+  } else {
+    v8_resource = v8::Object::New(isolate);
+  }
+
+  v8::Local<v8::String> v8_resource_name;
+  CHECK_TO_STRING(env, context, v8_resource_name, async_resource_name);
+
+  // TODO(jasongin): Consider avoiding allocation here by using
+  // a tagged pointer with 2×31 bit fields instead.
+  node::async_context* async_context = new node::async_context();
+
+  *async_context = node::EmitAsyncInit(isolate, v8_resource, v8_resource_name);
+  *result = reinterpret_cast<napi_async_context>(async_context);
+
+  return napi_clear_last_error(env);
+}
+
+napi_status napi_async_destroy(napi_env env,
+                               napi_async_context async_context) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, async_context);
+
+  v8::Isolate* isolate = env->isolate;
+  node::async_context* node_async_context =
+      reinterpret_cast<node::async_context*>(async_context);
+  node::EmitAsyncDestroy(isolate, *node_async_context);
+
+  return napi_clear_last_error(env);
+}
+
 napi_status napi_make_callback(napi_env env,
+                               napi_async_context async_context,
                                napi_value recv,
                                napi_value func,
                                size_t argc,
@@ -2791,12 +2836,22 @@ napi_status napi_make_callback(napi_env env,
   v8::Local<v8::Function> v8func;
   CHECK_TO_FUNCTION(env, v8func, func);
 
-  v8::Local<v8::Value> callback_result = node::MakeCallback(
+  node::async_context* node_async_context =
+    reinterpret_cast<node::async_context*>(async_context);
+  if (node_async_context == nullptr) {
+    static node::async_context empty_context = { 0, 0 };
+    node_async_context = &empty_context;
+  }
+
+  v8::MaybeLocal<v8::Value> callback_result = node::MakeCallback(
       isolate, v8recv, v8func, argc,
-      reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(argv)));
+      reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(argv)),
+      *node_async_context);
+  CHECK_MAYBE_EMPTY(env, callback_result, napi_generic_failure);
 
   if (result != nullptr) {
-    *result = v8impl::JsValueFromV8LocalValue(callback_result);
+    *result = v8impl::JsValueFromV8LocalValue(
+        callback_result.ToLocalChecked());
   }
 
   return GET_RETURN_STATUS(env);
diff --git a/src/node_api.h b/src/node_api.h
index cdc3a6bdb7ebe3..c7d5e746f1b98d 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -318,14 +318,6 @@ NAPI_EXTERN napi_status napi_instanceof(napi_env env,
                                         napi_value constructor,
                                         bool* result);
 
-// Napi version of node::MakeCallback(...)
-NAPI_EXTERN napi_status napi_make_callback(napi_env env,
-                                           napi_value recv,
-                                           napi_value func,
-                                           size_t argc,
-                                           const napi_value* argv,
-                                           napi_value* result);
-
 // Methods to work with napi_callbacks
 
 // Gets all callback info in a single call. (Ugly, but faster.)
@@ -535,6 +527,22 @@ NAPI_EXTERN napi_status napi_queue_async_work(napi_env env,
 NAPI_EXTERN napi_status napi_cancel_async_work(napi_env env,
                                                napi_async_work work);
 
+// Methods for custom handling of async operations
+NAPI_EXTERN napi_status napi_async_init(napi_env env,
+                                        napi_value async_resource,
+                                        napi_value async_resource_name,
+                                        napi_async_context* result);
+
+NAPI_EXTERN napi_status napi_async_destroy(napi_env env,
+                                           napi_async_context async_context);
+
+NAPI_EXTERN napi_status napi_make_callback(napi_env env,
+                                           napi_async_context async_context,
+                                           napi_value recv,
+                                           napi_value func,
+                                           size_t argc,
+                                           const napi_value* argv,
+                                           napi_value* result);
 
 // version management
 NAPI_EXTERN napi_status napi_get_version(napi_env env, uint32_t* result);
diff --git a/src/node_api_backport.cc b/src/node_api_backport.cc
index 249e3e8100efef..bd2c33242a4af7 100644
--- a/src/node_api_backport.cc
+++ b/src/node_api_backport.cc
@@ -81,6 +81,26 @@ AsyncResource::~AsyncResource() {
   object.Reset();
 }
 
+async_context EmitAsyncInit(v8::Isolate* isolate,
+                            v8::Local<v8::Object> resource,
+                            v8::Local<v8::String> name,
+                            async_id trigger_async_id) {
+  return async_context();
+}
+
+void EmitAsyncDestroy(v8::Isolate* isolate,
+                      async_context asyncContext) {
+}
+
+v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate* isolate,
+                                       v8::Local<v8::Object> recv,
+                                       v8::Local<v8::Function> callback,
+                                       int argc,
+                                       v8::Local<v8::Value>* argv,
+                                       async_context asyncContext) {
+  return node::MakeCallback(isolate, recv, callback, argc, argv);
+}
+
 }  // end of namespace node
 
 CallbackScope::CallbackScope(node::AsyncResource* work) :
diff --git a/src/node_api_backport.h b/src/node_api_backport.h
index 549b3ed42033de..9ef12cebd8f677 100644
--- a/src/node_api_backport.h
+++ b/src/node_api_backport.h
@@ -31,6 +31,21 @@ class CallbackScope {
   Environment::AsyncCallbackScope callback_scope;
 };
 
+NODE_EXTERN async_context EmitAsyncInit(v8::Isolate* isolate,
+                                        v8::Local<v8::Object> resource,
+                                        v8::Local<v8::String> name,
+                                        async_id trigger_async_id = -1);
+
+NODE_EXTERN void EmitAsyncDestroy(v8::Isolate* isolate,
+                                  async_context asyncContext);
+
+v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate* isolate,
+                                       v8::Local<v8::Object> recv,
+                                       v8::Local<v8::Function> callback,
+                                       int argc,
+                                       v8::Local<v8::Value>* argv,
+                                       async_context asyncContext);
+
 class AsyncResource {
  public:
   AsyncResource(v8::Isolate* _isolate,
diff --git a/src/node_api_types.h b/src/node_api_types.h
index ac8482bf9dcf9d..574cb6ff984f16 100644
--- a/src/node_api_types.h
+++ b/src/node_api_types.h
@@ -16,6 +16,7 @@ typedef struct napi_ref__ *napi_ref;
 typedef struct napi_handle_scope__ *napi_handle_scope;
 typedef struct napi_escapable_handle_scope__ *napi_escapable_handle_scope;
 typedef struct napi_callback_info__ *napi_callback_info;
+typedef struct napi_async_context__ *napi_async_context;
 typedef struct napi_async_work__ *napi_async_work;
 typedef struct napi_deferred__ *napi_deferred;
 
diff --git a/test/addons-napi/test_make_callback/binding.cc b/test/addons-napi/test_make_callback/binding.cc
index 1ba28c0ef40b72..9032e8b2f3f301 100644
--- a/test/addons-napi/test_make_callback/binding.cc
+++ b/test/addons-napi/test_make_callback/binding.cc
@@ -24,14 +24,22 @@ napi_value MakeCallback(napi_env env, napi_callback_info info) {
 
   NAPI_CALL(env, napi_typeof(env, func, &func_type));
 
+  napi_value resource_name;
+  NAPI_CALL(env, napi_create_string_utf8(env, "test", -1, &resource_name));
+
+  napi_async_context context;
+  NAPI_CALL(env, napi_async_init(env, func, resource_name, &context));
+
   napi_value result;
   if (func_type == napi_function) {
-    NAPI_CALL(env,
-      napi_make_callback(env, recv, func, argv.size(), argv.data(), &result));
+    NAPI_CALL(env, napi_make_callback(
+        env, context, recv, func, argv.size(), argv.data(), &result));
   } else {
     NAPI_ASSERT(env, false, "Unexpected argument type");
   }
 
+  NAPI_CALL(env, napi_async_destroy(env, context));
+
   return result;
 }
 
diff --git a/test/addons-napi/test_make_callback/test.js b/test/addons-napi/test_make_callback/test.js
index c4f24872bdb78e..56e2b3f4e2b6c6 100644
--- a/test/addons-napi/test_make_callback/test.js
+++ b/test/addons-napi/test_make_callback/test.js
@@ -7,7 +7,6 @@ const binding = require(`./build/${common.buildType}/binding`);
 const makeCallback = binding.makeCallback;
 
 function myMultiArgFunc(arg1, arg2, arg3) {
-  console.log(`MyFunc was called with ${arguments.length} arguments`);
   assert.strictEqual(arg1, 1);
   assert.strictEqual(arg2, 2);
   assert.strictEqual(arg3, 3);
diff --git a/test/addons-napi/test_make_callback_recurse/binding.cc b/test/addons-napi/test_make_callback_recurse/binding.cc
index f3c80ab103406e..d0ee1ddb4998e6 100644
--- a/test/addons-napi/test_make_callback_recurse/binding.cc
+++ b/test/addons-napi/test_make_callback_recurse/binding.cc
@@ -12,8 +12,8 @@ napi_value MakeCallback(napi_env env, napi_callback_info info) {
   napi_value recv = args[0];
   napi_value func = args[1];
 
-  napi_make_callback(env,
-      recv, func, 0 /* argc */, nullptr /* argv */, nullptr /* result */);
+  napi_make_callback(env, nullptr /* async_context */,
+    recv, func, 0 /* argc */, nullptr /* argv */, nullptr /* result */);
 
   return recv;
 }

From 574f09e48668032f451386c288f8c100895613c4 Mon Sep 17 00:00:00 2001
From: Sampson Gao <sampsong@ca.ibm.com>
Date: Tue, 8 Aug 2017 16:21:56 -0400
Subject: [PATCH 106/183] n-api: napi_is_construct_call->napi_get_new_target

Remove napi_is_construct_call and introduce napi_get_new_target.

PR-URL: https://github.com/nodejs/node/pull/14698
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Kyle Farnung <kfarnung@microsoft.com>
---
 doc/api/n-api.md                           | 17 ++++++++--------
 src/node_api.cc                            | 23 ++++++++++++----------
 src/node_api.h                             |  6 +++---
 test/addons-napi/6_object_wrap/myobject.cc |  5 +++--
 4 files changed, 27 insertions(+), 24 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 1d9b405c78a07e..4797e62fd97d46 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -2928,25 +2928,24 @@ Returns `napi_ok` if the API succeeded.
 This method is used within a callback function to retrieve details about the
 call like the arguments and the `this` pointer from a given callback info.
 
-### *napi_is_construct_call*
+### *napi_get_new_target*
 <!-- YAML
-added: v8.0.0
+added: REPLACEME
 -->
 ```C
-napi_status napi_is_construct_call(napi_env env,
-                                   napi_callback_info cbinfo,
-                                   bool* result)
+napi_status napi_get_new_target(napi_env env,
+                                napi_callback_info cbinfo,
+                                napi_value* result)
 ```
 
 - `[in] env`: The environment that the API is invoked under.
 - `[in] cbinfo`: The callback info passed into the callback function.
-- `[out] result`: Whether the native function is being invoked as
-a constructor call.
+- `[out] result`: The `new.target` of the constructor call.
 
 Returns `napi_ok` if the API succeeded.
 
-This API checks if the the current callback was due to a
-consructor call.
+This API returns the `new.target` of the constructor call. If the current
+callback is not a constructor call, the result is `nullptr`.
 
 ### *napi_new_instance*
 <!-- YAML
diff --git a/src/node_api.cc b/src/node_api.cc
index 246b3fd8085a41..7c68abfc6797de 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -451,7 +451,7 @@ class CallbackWrapper {
   CallbackWrapper(napi_value this_arg, size_t args_length, void* data)
       : _this(this_arg), _args_length(args_length), _data(data) {}
 
-  virtual bool IsConstructCall() = 0;
+  virtual napi_value NewTarget() = 0;
   virtual void Args(napi_value* buffer, size_t bufferlength) = 0;
   virtual void SetReturnValue(napi_value value) = 0;
 
@@ -480,8 +480,7 @@ class CallbackWrapperBase : public CallbackWrapper {
                 ->Value();
   }
 
-  /*virtual*/
-  bool IsConstructCall() override { return false; }
+  napi_value NewTarget() override { return nullptr; }
 
  protected:
   void InvokeCallback() {
@@ -529,8 +528,13 @@ class FunctionCallbackWrapper
       const v8::FunctionCallbackInfo<v8::Value>& cbinfo)
       : CallbackWrapperBase(cbinfo, cbinfo.Length()) {}
 
-  /*virtual*/
-  bool IsConstructCall() override { return _cbinfo.IsConstructCall(); }
+  napi_value NewTarget() override {
+    if (_cbinfo.IsConstructCall()) {
+      return v8impl::JsValueFromV8LocalValue(_cbinfo.NewTarget());
+    } else {
+      return nullptr;
+    }
+  }
 
   /*virtual*/
   void Args(napi_value* buffer, size_t buffer_length) override {
@@ -1883,10 +1887,9 @@ napi_status napi_get_cb_info(
   return napi_clear_last_error(env);
 }
 
-napi_status napi_is_construct_call(napi_env env,
-                                   napi_callback_info cbinfo,
-                                   bool* result) {
-  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because no V8 APIs are called.
+napi_status napi_get_new_target(napi_env env,
+                                napi_callback_info cbinfo,
+                                napi_value* result) {
   CHECK_ENV(env);
   CHECK_ARG(env, cbinfo);
   CHECK_ARG(env, result);
@@ -1894,7 +1897,7 @@ napi_status napi_is_construct_call(napi_env env,
   v8impl::CallbackWrapper* info =
       reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
 
-  *result = info->IsConstructCall();
+  *result = info->NewTarget();
   return napi_clear_last_error(env);
 }
 
diff --git a/src/node_api.h b/src/node_api.h
index c7d5e746f1b98d..e1a40983a9907d 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -330,9 +330,9 @@ NAPI_EXTERN napi_status napi_get_cb_info(
     napi_value* this_arg,  // [out] Receives the JS 'this' arg for the call
     void** data);          // [out] Receives the data pointer for the callback.
 
-NAPI_EXTERN napi_status napi_is_construct_call(napi_env env,
-                                               napi_callback_info cbinfo,
-                                               bool* result);
+NAPI_EXTERN napi_status napi_get_new_target(napi_env env,
+                                            napi_callback_info cbinfo,
+                                            napi_value* result);
 NAPI_EXTERN napi_status
 napi_define_class(napi_env env,
                   const char* utf8name,
diff --git a/test/addons-napi/6_object_wrap/myobject.cc b/test/addons-napi/6_object_wrap/myobject.cc
index c214e014b9eb12..90815253add651 100644
--- a/test/addons-napi/6_object_wrap/myobject.cc
+++ b/test/addons-napi/6_object_wrap/myobject.cc
@@ -32,8 +32,9 @@ void MyObject::Init(napi_env env, napi_value exports) {
 }
 
 napi_value MyObject::New(napi_env env, napi_callback_info info) {
-  bool is_constructor;
-  NAPI_CALL(env, napi_is_construct_call(env, info, &is_constructor));
+  napi_value new_target;
+  NAPI_CALL(env, napi_get_new_target(env, info, &new_target));
+  bool is_constructor = (new_target != nullptr);
 
   size_t argc = 1;
   napi_value args[1];

From 7fb617b76d1a2064e689587e2fa4316578b9b7b9 Mon Sep 17 00:00:00 2001
From: Sampson Gao <sampsong@ca.ibm.com>
Date: Mon, 11 Sep 2017 09:57:38 -0400
Subject: [PATCH 107/183] n-api: add optional string length parameters

PR-URL: https://github.com/nodejs/node/pull/15343
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
---
 doc/api/n-api.md                              | 15 ++++++++++-
 src/node_api.cc                               | 26 ++++++++++++++++---
 src/node_api.h                                |  6 ++++-
 test/addons-napi/4_object_factory/binding.c   |  2 +-
 test/addons-napi/5_function_factory/binding.c |  6 ++---
 test/addons-napi/6_object_wrap/myobject.cc    |  4 +--
 test/addons-napi/7_factory_wrap/binding.cc    |  2 +-
 test/addons-napi/7_factory_wrap/myobject.cc   |  4 +--
 .../addons-napi/8_passing_wrapped/myobject.cc |  3 ++-
 test/addons-napi/test_constructor/binding.gyp |  4 +++
 test/addons-napi/test_constructor/test2.js    |  8 ++++++
 .../test_constructor/test_constructor.c       |  2 +-
 .../test_constructor/test_constructor_name.c  | 23 ++++++++++++++++
 .../test_env_sharing/compare_env.c            |  2 +-
 test/addons-napi/test_fatal/test2.js          | 18 +++++++++++++
 test/addons-napi/test_fatal/test_fatal.c      |  8 +++++-
 test/addons-napi/test_function/test.js        | 11 +++++---
 .../addons-napi/test_function/test_function.c | 23 +++++++++++++---
 .../addons-napi/test_make_callback/binding.cc |  2 +-
 .../test_make_callback_recurse/binding.cc     |  2 +-
 20 files changed, 141 insertions(+), 30 deletions(-)
 create mode 100644 test/addons-napi/test_constructor/test2.js
 create mode 100644 test/addons-napi/test_constructor/test_constructor_name.c
 create mode 100644 test/addons-napi/test_fatal/test2.js

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 4797e62fd97d46..3bfd0b438cd38f 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -552,11 +552,18 @@ thrown to immediately terminate the process.
 added: REPLACEME
 -->
 ```C
-NAPI_NO_RETURN void napi_fatal_error(const char* location, const char* message);
+NAPI_NO_RETURN void napi_fatal_error(const char* location,
+                                                 size_t location_len,
+                                                 const char* message,
+                                                 size_t message_len);
 ```
 
 - `[in] location`: Optional location at which the error occurred.
+- `[in] location_len`: The length of the location in bytes, or -1 if it is
+null-terminated.
 - `[in] message`: The message associated with the error.
+- `[in] message_len`: The length of the message in bytes, or -1 if it is
+null-terminated.
 
 The function call does not return, the process will be terminated.
 
@@ -1248,6 +1255,7 @@ added: v8.0.0
 ```C
 napi_status napi_create_function(napi_env env,
                                  const char* utf8name,
+                                 size_t length,
                                  napi_callback cb,
                                  void* data,
                                  napi_value* result)
@@ -1256,6 +1264,8 @@ napi_status napi_create_function(napi_env env,
 - `[in] env`: The environment that the API is invoked under.
 - `[in] utf8name`: A string representing the name of the function encoded as
 UTF8.
+- `[in] length`: The length of the utf8name in bytes, or -1 if it is
+null-terminated.
 - `[in] cb`: A function pointer to the native function to be invoked when the
 created function is invoked from JavaScript.
 - `[in] data`: Optional arbitrary context data to be passed into the native
@@ -3026,6 +3036,7 @@ added: v8.0.0
 ```C
 napi_status napi_define_class(napi_env env,
                               const char* utf8name,
+                              size_t length,
                               napi_callback constructor,
                               void* data,
                               size_t property_count,
@@ -3037,6 +3048,8 @@ napi_status napi_define_class(napi_env env,
  - `[in] utf8name`: Name of the JavaScript constructor function; this is
    not required to be the same as the C++ class name, though it is recommended
    for clarity.
+ - `[in] length`: The length of the utf8name in bytes, or -1 if it is
+null-terminated.
  - `[in] constructor`: Callback function that handles constructing instances
    of the class. (This should be a static method on the class, not an actual
    C++ constructor function.)
diff --git a/src/node_api.cc b/src/node_api.cc
index 7c68abfc6797de..44751a8f945da9 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -938,12 +938,29 @@ napi_status napi_get_last_error_info(napi_env env,
 }
 
 NAPI_NO_RETURN void napi_fatal_error(const char* location,
-                                     const char* message) {
-  node::FatalError(location, message);
+                                     size_t location_len,
+                                     const char* message,
+                                     size_t message_len) {
+  char* location_string = const_cast<char*>(location);
+  char* message_string = const_cast<char*>(message);
+  if (location_len != -1) {
+    location_string = reinterpret_cast<char*>(
+        malloc(location_len * sizeof(char) + 1));
+    strncpy(location_string, location, location_len);
+    location_string[location_len] = '\0';
+  }
+  if (message_len != -1) {
+    message_string = reinterpret_cast<char*>(
+        malloc(message_len * sizeof(char) + 1));
+    strncpy(message_string, message, message_len);
+    message_string[message_len] = '\0';
+  }
+  node::FatalError(location_string, message_string);
 }
 
 napi_status napi_create_function(napi_env env,
                                  const char* utf8name,
+                                 size_t length,
                                  napi_callback cb,
                                  void* callback_data,
                                  napi_value* result) {
@@ -970,7 +987,7 @@ napi_status napi_create_function(napi_env env,
 
   if (utf8name != nullptr) {
     v8::Local<v8::String> name_string;
-    CHECK_NEW_FROM_UTF8(env, name_string, utf8name);
+    CHECK_NEW_FROM_UTF8_LEN(env, name_string, utf8name, length);
     return_value->SetName(name_string);
   }
 
@@ -981,6 +998,7 @@ napi_status napi_create_function(napi_env env,
 
 napi_status napi_define_class(napi_env env,
                               const char* utf8name,
+                              size_t length,
                               napi_callback constructor,
                               void* callback_data,
                               size_t property_count,
@@ -1002,7 +1020,7 @@ napi_status napi_define_class(napi_env env,
       isolate, v8impl::FunctionCallbackWrapper::Invoke, cbdata);
 
   v8::Local<v8::String> name_string;
-  CHECK_NEW_FROM_UTF8(env, name_string, utf8name);
+  CHECK_NEW_FROM_UTF8_LEN(env, name_string, utf8name, length);
   tpl->SetClassName(name_string);
 
   size_t static_property_count = 0;
diff --git a/src/node_api.h b/src/node_api.h
index e1a40983a9907d..82f2e1900e2fe4 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -109,7 +109,9 @@ napi_get_last_error_info(napi_env env,
                          const napi_extended_error_info** result);
 
 NAPI_EXTERN NAPI_NO_RETURN void napi_fatal_error(const char* location,
-                                                 const char* message);
+                                                 size_t location_len,
+                                                 const char* message,
+                                                 size_t message_len);
 
 // Getters for defined singletons
 NAPI_EXTERN napi_status napi_get_undefined(napi_env env, napi_value* result);
@@ -154,6 +156,7 @@ NAPI_EXTERN napi_status napi_create_symbol(napi_env env,
                                            napi_value* result);
 NAPI_EXTERN napi_status napi_create_function(napi_env env,
                                              const char* utf8name,
+                                             size_t length,
                                              napi_callback cb,
                                              void* data,
                                              napi_value* result);
@@ -336,6 +339,7 @@ NAPI_EXTERN napi_status napi_get_new_target(napi_env env,
 NAPI_EXTERN napi_status
 napi_define_class(napi_env env,
                   const char* utf8name,
+                  size_t length,
                   napi_callback constructor,
                   void* data,
                   size_t property_count,
diff --git a/test/addons-napi/4_object_factory/binding.c b/test/addons-napi/4_object_factory/binding.c
index fe509c02ad13b6..6bdca80ec365be 100644
--- a/test/addons-napi/4_object_factory/binding.c
+++ b/test/addons-napi/4_object_factory/binding.c
@@ -16,7 +16,7 @@ napi_value CreateObject(napi_env env, napi_callback_info info) {
 
 napi_value Init(napi_env env, napi_value exports) {
   NAPI_CALL(env,
-      napi_create_function(env, "exports", CreateObject, NULL, &exports));
+      napi_create_function(env, "exports", -1, CreateObject, NULL, &exports));
   return exports;
 }
 
diff --git a/test/addons-napi/5_function_factory/binding.c b/test/addons-napi/5_function_factory/binding.c
index a2e03dd9bdd6b5..6b2b6f8f0ebe81 100644
--- a/test/addons-napi/5_function_factory/binding.c
+++ b/test/addons-napi/5_function_factory/binding.c
@@ -4,21 +4,19 @@
 napi_value MyFunction(napi_env env, napi_callback_info info) {
   napi_value str;
   NAPI_CALL(env, napi_create_string_utf8(env, "hello world", -1, &str));
-
   return str;
 }
 
 napi_value CreateFunction(napi_env env, napi_callback_info info) {
   napi_value fn;
   NAPI_CALL(env,
-      napi_create_function(env, "theFunction", MyFunction, NULL, &fn));
-
+    napi_create_function(env, "theFunction", -1, MyFunction, NULL, &fn));
   return fn;
 }
 
 napi_value Init(napi_env env, napi_value exports) {
   NAPI_CALL(env,
-      napi_create_function(env, "exports", CreateFunction, NULL, &exports));
+      napi_create_function(env, "exports", -1, CreateFunction, NULL, &exports));
   return exports;
 }
 
diff --git a/test/addons-napi/6_object_wrap/myobject.cc b/test/addons-napi/6_object_wrap/myobject.cc
index 90815253add651..aca91877d3a2ae 100644
--- a/test/addons-napi/6_object_wrap/myobject.cc
+++ b/test/addons-napi/6_object_wrap/myobject.cc
@@ -22,8 +22,8 @@ void MyObject::Init(napi_env env, napi_value exports) {
   };
 
   napi_value cons;
-  NAPI_CALL_RETURN_VOID(env,
-      napi_define_class(env, "MyObject", New, nullptr, 3, properties, &cons));
+  NAPI_CALL_RETURN_VOID(env, napi_define_class(
+      env, "MyObject", -1, New, nullptr, 3, properties, &cons));
 
   NAPI_CALL_RETURN_VOID(env, napi_create_reference(env, cons, 1, &constructor));
 
diff --git a/test/addons-napi/7_factory_wrap/binding.cc b/test/addons-napi/7_factory_wrap/binding.cc
index 4d02247f85b924..9d8f23c561d77a 100644
--- a/test/addons-napi/7_factory_wrap/binding.cc
+++ b/test/addons-napi/7_factory_wrap/binding.cc
@@ -16,7 +16,7 @@ napi_value Init(napi_env env, napi_value exports) {
   NAPI_CALL(env, MyObject::Init(env));
 
   NAPI_CALL(env,
-      napi_create_function(env, "exports", CreateObject, NULL, &exports));
+      napi_create_function(env, "exports", -1, CreateObject, NULL, &exports));
   return exports;
 }
 
diff --git a/test/addons-napi/7_factory_wrap/myobject.cc b/test/addons-napi/7_factory_wrap/myobject.cc
index c6d538a7cefbc6..4e1d79c1febc17 100644
--- a/test/addons-napi/7_factory_wrap/myobject.cc
+++ b/test/addons-napi/7_factory_wrap/myobject.cc
@@ -21,8 +21,8 @@ napi_status MyObject::Init(napi_env env) {
   };
 
   napi_value cons;
-  status =
-      napi_define_class(env, "MyObject", New, nullptr, 1, properties, &cons);
+  status = napi_define_class(
+      env, "MyObject", -1, New, nullptr, 1, properties, &cons);
   if (status != napi_ok) return status;
 
   status = napi_create_reference(env, cons, 1, &constructor);
diff --git a/test/addons-napi/8_passing_wrapped/myobject.cc b/test/addons-napi/8_passing_wrapped/myobject.cc
index 0c24d7696e66ec..19cc7dd2a29493 100644
--- a/test/addons-napi/8_passing_wrapped/myobject.cc
+++ b/test/addons-napi/8_passing_wrapped/myobject.cc
@@ -17,7 +17,8 @@ napi_status MyObject::Init(napi_env env) {
   napi_status status;
 
   napi_value cons;
-  status = napi_define_class(env, "MyObject", New, nullptr, 0, nullptr, &cons);
+  status = napi_define_class(
+      env, "MyObject", -1, New, nullptr, 0, nullptr, &cons);
   if (status != napi_ok) return status;
 
   status = napi_create_reference(env, cons, 1, &constructor);
diff --git a/test/addons-napi/test_constructor/binding.gyp b/test/addons-napi/test_constructor/binding.gyp
index 55140e7c379f02..1945a9fd5a711e 100644
--- a/test/addons-napi/test_constructor/binding.gyp
+++ b/test/addons-napi/test_constructor/binding.gyp
@@ -3,6 +3,10 @@
     {
       "target_name": "test_constructor",
       "sources": [ "test_constructor.c" ]
+    },
+    {
+      "target_name": "test_constructor_name",
+      "sources": [ "test_constructor_name.c" ]
     }
   ]
 }
diff --git a/test/addons-napi/test_constructor/test2.js b/test/addons-napi/test_constructor/test2.js
new file mode 100644
index 00000000000000..64c03cbc684ac3
--- /dev/null
+++ b/test/addons-napi/test_constructor/test2.js
@@ -0,0 +1,8 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+
+// Testing api calls for a constructor that defines properties
+const TestConstructor =
+    require(`./build/${common.buildType}/test_constructor_name`);
+assert.strictEqual(TestConstructor.name, 'MyObject');
diff --git a/test/addons-napi/test_constructor/test_constructor.c b/test/addons-napi/test_constructor/test_constructor.c
index 437c32e12517fc..8b5b4e53ea7bc0 100644
--- a/test/addons-napi/test_constructor/test_constructor.c
+++ b/test/addons-napi/test_constructor/test_constructor.c
@@ -77,7 +77,7 @@ napi_value Init(napi_env env, napi_value exports) {
   };
 
   napi_value cons;
-  NAPI_CALL(env, napi_define_class(env, "MyObject", New,
+  NAPI_CALL(env, napi_define_class(env, "MyObject", -1, New,
       NULL, sizeof(properties)/sizeof(*properties), properties, &cons));
 
   NAPI_CALL(env, napi_create_reference(env, cons, 1, &constructor_));
diff --git a/test/addons-napi/test_constructor/test_constructor_name.c b/test/addons-napi/test_constructor/test_constructor_name.c
new file mode 100644
index 00000000000000..b178e80f49f489
--- /dev/null
+++ b/test/addons-napi/test_constructor/test_constructor_name.c
@@ -0,0 +1,23 @@
+#include <node_api.h>
+#include "../common.h"
+
+napi_ref constructor_;
+
+napi_value New(napi_env env, napi_callback_info info) {
+  napi_value _this;
+  NAPI_CALL(env, napi_get_cb_info(env, info, NULL, NULL, &_this, NULL));
+
+  return _this;
+}
+
+napi_value Init(napi_env env, napi_value exports) {
+  napi_value cons;
+  NAPI_CALL(env, napi_define_class(
+      env, "MyObject_Extra", 8, New, NULL, 0, NULL, &cons));
+
+  NAPI_CALL(env,
+      napi_create_reference(env, cons, 1, &constructor_));
+  return cons;
+}
+
+NAPI_MODULE(addon, Init)
diff --git a/test/addons-napi/test_env_sharing/compare_env.c b/test/addons-napi/test_env_sharing/compare_env.c
index df200f2a96f986..39adfb9b713ab3 100644
--- a/test/addons-napi/test_env_sharing/compare_env.c
+++ b/test/addons-napi/test_env_sharing/compare_env.c
@@ -15,7 +15,7 @@ napi_value compare(napi_env env, napi_callback_info info) {
 }
 
 napi_value Init(napi_env env, napi_value exports) {
-  NAPI_CALL(env, napi_create_function(env, "exports", compare, NULL, &exports));
+  NAPI_CALL(env, napi_create_function(env, "exports", -1, compare, NULL, &exports));
   return exports;
 }
 
diff --git a/test/addons-napi/test_fatal/test2.js b/test/addons-napi/test_fatal/test2.js
new file mode 100644
index 00000000000000..b9bde8f13016cc
--- /dev/null
+++ b/test/addons-napi/test_fatal/test2.js
@@ -0,0 +1,18 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const child_process = require('child_process');
+const test_fatal = require(`./build/${common.buildType}/test_fatal`);
+
+// Test in a child process because the test code will trigger a fatal error
+// that crashes the process.
+if (process.argv[2] === 'child') {
+  test_fatal.TestStringLength();
+  return;
+}
+
+const p = child_process.spawnSync(
+  process.execPath, [ '--napi-modules', __filename, 'child' ]);
+assert.ifError(p.error);
+assert.ok(p.stderr.toString().includes(
+  'FATAL ERROR: test_fatal::Test fatal message'));
diff --git a/test/addons-napi/test_fatal/test_fatal.c b/test/addons-napi/test_fatal/test_fatal.c
index f6cb2184a6e8e2..4159fa4b47f567 100644
--- a/test/addons-napi/test_fatal/test_fatal.c
+++ b/test/addons-napi/test_fatal/test_fatal.c
@@ -2,13 +2,19 @@
 #include "../common.h"
 
 napi_value Test(napi_env env, napi_callback_info info) {
-  napi_fatal_error("test_fatal::Test", "fatal message");
+  napi_fatal_error("test_fatal::Test", -1, "fatal message", -1);
+  return NULL;
+}
+
+napi_value TestStringLength(napi_env env, napi_callback_info info) {
+  napi_fatal_error("test_fatal::TestStringLength", 16, "fatal message", 13);
   return NULL;
 }
 
 napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor properties[] = {
     DECLARE_NAPI_PROPERTY("Test", Test),
+    DECLARE_NAPI_PROPERTY("TestStringLength", TestStringLength),
   };
 
   NAPI_CALL(env, napi_define_properties(
diff --git a/test/addons-napi/test_function/test.js b/test/addons-napi/test_function/test.js
index bdb9133adf9346..752e9965b23039 100644
--- a/test/addons-napi/test_function/test.js
+++ b/test/addons-napi/test_function/test.js
@@ -9,20 +9,23 @@ const test_function = require(`./build/${common.buildType}/test_function`);
 function func1() {
   return 1;
 }
-assert.strictEqual(test_function.Test(func1), 1);
+assert.strictEqual(test_function.TestCall(func1), 1);
 
 function func2() {
   console.log('hello world!');
   return null;
 }
-assert.strictEqual(test_function.Test(func2), null);
+assert.strictEqual(test_function.TestCall(func2), null);
 
 function func3(input) {
   return input + 1;
 }
-assert.strictEqual(test_function.Test(func3, 1), 2);
+assert.strictEqual(test_function.TestCall(func3, 1), 2);
 
 function func4(input) {
   return func3(input);
 }
-assert.strictEqual(test_function.Test(func4, 1), 2);
+assert.strictEqual(test_function.TestCall(func4, 1), 2);
+
+assert.strictEqual(test_function.TestName.name, 'Name');
+assert.strictEqual(test_function.TestNameShort.name, 'Name_');
diff --git a/test/addons-napi/test_function/test_function.c b/test/addons-napi/test_function/test_function.c
index 2cb25db5beaf03..77495d9b8a3a46 100644
--- a/test/addons-napi/test_function/test_function.c
+++ b/test/addons-napi/test_function/test_function.c
@@ -1,7 +1,7 @@
 #include <node_api.h>
 #include "../common.h"
 
-napi_value Test(napi_env env, napi_callback_info info) {
+napi_value TestCallFunction(napi_env env, napi_callback_info info) {
   size_t argc = 10;
   napi_value args[10];
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
@@ -26,10 +26,25 @@ napi_value Test(napi_env env, napi_callback_info info) {
   return result;
 }
 
+void TestFunctionName(napi_env env, napi_callback_info info) {}
+
 napi_value Init(napi_env env, napi_value exports) {
-  napi_value fn;
-  NAPI_CALL(env, napi_create_function(env, NULL, Test, NULL, &fn));
-  NAPI_CALL(env, napi_set_named_property(env, exports, "Test", fn));
+  napi_value fn1;
+  NAPI_CALL(env, napi_create_function(
+      env, NULL, -1, TestCallFunction, NULL, &fn1));
+
+  napi_value fn2;
+  NAPI_CALL(env, napi_create_function(
+      env, "Name", -1, TestFunctionName, NULL, &fn2));
+
+  napi_value fn3;
+  NAPI_CALL(env, napi_create_function(
+      env, "Name_extra", 5, TestFunctionName, NULL, &fn3));
+
+  NAPI_CALL(env, napi_set_named_property(env, exports, "TestCall", fn1));
+  NAPI_CALL(env, napi_set_named_property(env, exports, "TestName", fn2));
+  NAPI_CALL(env, napi_set_named_property(env, exports, "TestNameShort", fn3));
+
   return exports;
 }
 
diff --git a/test/addons-napi/test_make_callback/binding.cc b/test/addons-napi/test_make_callback/binding.cc
index 9032e8b2f3f301..18bf46764be40c 100644
--- a/test/addons-napi/test_make_callback/binding.cc
+++ b/test/addons-napi/test_make_callback/binding.cc
@@ -45,7 +45,7 @@ napi_value MakeCallback(napi_env env, napi_callback_info info) {
 
 napi_value Init(napi_env env, napi_value exports) {
   napi_value fn;
-  NAPI_CALL(env, napi_create_function(env, NULL, MakeCallback, NULL, &fn));
+  NAPI_CALL(env, napi_create_function(env, NULL, -1, MakeCallback, NULL, &fn));
   NAPI_CALL(env, napi_set_named_property(env, exports, "makeCallback", fn));
   return exports;
 }
diff --git a/test/addons-napi/test_make_callback_recurse/binding.cc b/test/addons-napi/test_make_callback_recurse/binding.cc
index d0ee1ddb4998e6..ea823294352490 100644
--- a/test/addons-napi/test_make_callback_recurse/binding.cc
+++ b/test/addons-napi/test_make_callback_recurse/binding.cc
@@ -20,7 +20,7 @@ napi_value MakeCallback(napi_env env, napi_callback_info info) {
 
 napi_value Init(napi_env env, napi_value exports) {
   napi_value fn;
-  NAPI_CALL(env, napi_create_function(env, NULL, MakeCallback, NULL, &fn));
+  NAPI_CALL(env, napi_create_function(env, NULL, -1, MakeCallback, NULL, &fn));
   NAPI_CALL(env, napi_set_named_property(env, exports, "makeCallback", fn));
   return exports;
 }

From a61dd4b6300ff2a3c2d964d2d3388731789f0fb4 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Fri, 18 Aug 2017 13:30:05 +0300
Subject: [PATCH 108/183] n-api: remove n-api module loading flag

Remove the command line flag that was needed for N-API module loading.
Re: https://github.com/nodejs/vm/issues/9

PR-URL: https://github.com/nodejs/node/pull/14902
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Hitesh Kanwathirtha <digitalinfinity@gmail.com>
---
 doc/api/cli.md                                |  9 -----
 doc/api/n-api.md                              |  8 ----
 src/env-inl.h                                 |  1 +
 src/env.cc                                    |  6 +++
 src/env.h                                     |  3 ++
 src/node.cc                                   | 38 +++++++------------
 src/node_api.cc                               | 20 +---------
 test/addons-napi/test_async/test.js           |  2 +-
 test/addons-napi/test_fatal/test.js           |  4 +-
 .../addons-napi/test_function/test_function.c |  4 +-
 test/addons-napi/test_warning/binding.gyp     | 12 ++++++
 test/addons-napi/test_warning/test.js         | 18 +++++++++
 test/addons-napi/test_warning/test_warning.c  | 11 ++++++
 test/addons-napi/test_warning/test_warning2.c | 11 ++++++
 test/addons-napi/testcfg.py                   |  2 +-
 15 files changed, 83 insertions(+), 66 deletions(-)
 create mode 100644 test/addons-napi/test_warning/binding.gyp
 create mode 100644 test/addons-napi/test_warning/test.js
 create mode 100644 test/addons-napi/test_warning/test_warning.c
 create mode 100644 test/addons-napi/test_warning/test_warning2.c

diff --git a/doc/api/cli.md b/doc/api/cli.md
index 5bcb6f3b4d0107..84876ea181d0a8 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -119,14 +119,6 @@ added: v6.0.0
 
 Silence all process warnings (including deprecations).
 
-### `--napi-modules`
-<!-- YAML
-added: REPLACEME
--->
-
-Enable loading native modules compiled with the ABI-stable Node.js API (N-API)
-(experimental).
-
 ### `--trace-warnings`
 <!-- YAML
 added: v6.0.0
@@ -361,7 +353,6 @@ Node options that are allowed are:
 - `--debug-brk`
 - `--debug-port`
 - `--debug`
-- `--napi-modules`
 - `--no-deprecation`
 - `--no-warnings`
 - `--openssl-config`
diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 3bfd0b438cd38f..1d3d00f043bf97 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -63,14 +63,6 @@ For example:
 #include <node_api.h>
 ```
 
-As the feature is experimental it must be enabled with the
-following command line
-[option](https://nodejs.org/dist/latest-v8.x/docs/api/cli.html#cli_napi_modules):
-
-```bash
---napi-modules
-```
-
 ## Basic N-API Data Types
 
 N-API exposes the following fundamental datatypes as abstractions that are
diff --git a/src/env-inl.h b/src/env-inl.h
index 30d7950e93950d..45a327de16931d 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -223,6 +223,7 @@ inline Environment::Environment(v8::Local<v8::Context> context,
       using_domains_(false),
       printed_error_(false),
       trace_sync_io_(false),
+      emit_napi_warning_(true),
       makecallback_cntr_(0),
       async_wrap_uid_(0),
       debugger_agent_(this),
diff --git a/src/env.cc b/src/env.cc
index 5090475499dcaf..0b31afdf2eaf23 100644
--- a/src/env.cc
+++ b/src/env.cc
@@ -61,4 +61,10 @@ void Environment::PrintSyncTrace() const {
   fflush(stderr);
 }
 
+bool Environment::EmitNapiWarning() {
+  bool current_value = emit_napi_warning_;
+  emit_napi_warning_ = false;
+  return current_value;
+}
+
 }  // namespace node
diff --git a/src/env.h b/src/env.h
index c4489857161b75..36ca7004ad748c 100644
--- a/src/env.h
+++ b/src/env.h
@@ -535,6 +535,8 @@ class Environment {
 
   static const int kContextEmbedderDataIndex = NODE_CONTEXT_EMBEDDER_DATA_INDEX;
 
+  bool EmitNapiWarning();
+
  private:
   inline void ThrowError(v8::Local<v8::Value> (*fun)(v8::Local<v8::String>),
                          const char* errmsg);
@@ -566,6 +568,7 @@ class Environment {
   bool using_domains_;
   bool printed_error_;
   bool trace_sync_io_;
+  bool emit_napi_warning_;
   size_t makecallback_cntr_;
   int64_t async_wrap_uid_;
   std::vector<int64_t> destroy_ids_list_;
diff --git a/src/node.cc b/src/node.cc
index 454342cd52224b..537bc152bcafd1 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -167,9 +167,6 @@ static node_module* modlist_addon;
 static std::string icu_data_dir;  // NOLINT(runtime/string)
 #endif
 
-// N-API is in experimental state, disabled by default.
-bool load_napi_modules = false;
-
 // used by C++ modules as well
 bool no_deprecation = false;
 
@@ -2503,22 +2500,17 @@ void DLOpen(const FunctionCallbackInfo<Value>& args) {
     env->ThrowError("Module did not self-register.");
     return;
   }
-  if (mp->nm_version != NODE_MODULE_VERSION) {
-    char errmsg[1024];
-    if (mp->nm_version == -1) {
-      snprintf(errmsg,
-               sizeof(errmsg),
-               "The module '%s'"
-               "\nwas compiled against the ABI-stable Node.js API (N-API)."
-               "\nThis feature is experimental and must be enabled on the "
-               "\ncommand-line by adding --napi-modules.",
-               *filename);
-    } else {
-      snprintf(errmsg,
-               sizeof(errmsg),
-               "Module version mismatch. Expected %d, got %d.",
-               NODE_MODULE_VERSION, mp->nm_version);
+  if (mp->nm_version == -1) {
+    if (env->EmitNapiWarning()) {
+      ProcessEmitWarning(env, "N-API is an experimental feature and could "
+                         "change at any time.");
     }
+  } else if (mp->nm_version != NODE_MODULE_VERSION) {
+    char errmsg[1024];
+    snprintf(errmsg,
+             sizeof(errmsg),
+             "Module version mismatch. Expected %d, got %d.",
+             NODE_MODULE_VERSION, mp->nm_version);
 
     // NOTE: `mp` is allocated inside of the shared library's memory, calling
     // `uv_dlclose` will deallocate it
@@ -3733,7 +3725,8 @@ static void PrintHelp() {
          "  --throw-deprecation   throw an exception anytime a deprecated "
          "function is used\n"
          "  --no-warnings         silence all process warnings\n"
-         "  --napi-modules        load N-API modules\n"
+         "  --napi-modules        load N-API modules (no-op - option kept for "
+         "                        compatibility)\n"
          "  --trace-warnings      show stack traces on process warnings\n"
          "  --redirect-warnings=path\n"
          "                        write warnings to path instead of stderr\n"
@@ -3980,7 +3973,7 @@ static void ParseArgs(int* argc,
     } else if (strcmp(arg, "--no-deprecation") == 0) {
       no_deprecation = true;
     } else if (strcmp(arg, "--napi-modules") == 0) {
-      load_napi_modules = true;
+      // no-op
     } else if (strcmp(arg, "--no-warnings") == 0) {
       no_process_warnings = true;
     } else if (strcmp(arg, "--trace-warnings") == 0) {
@@ -4879,11 +4872,6 @@ static void StartNodeInstance(void* arg) {
     if (instance_data->use_debug_agent())
       EnableDebug(env);
 
-    if (load_napi_modules) {
-      ProcessEmitWarning(env, "N-API is an experimental feature "
-          "and could change at any time.");
-    }
-
     {
       SealHandleScope seal(isolate);
       bool more;
diff --git a/src/node_api.cc b/src/node_api.cc
index 44751a8f945da9..b6caca97c0dabe 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -846,28 +846,10 @@ void napi_module_register_cb(v8::Local<v8::Object> exports,
   }
 }
 
-#ifndef EXTERNAL_NAPI
-namespace node {
-  // Indicates whether NAPI was enabled/disabled via the node command-line.
-  extern bool load_napi_modules;
-}
-#endif  // EXTERNAL_NAPI
-
 // Registers a NAPI module.
 void napi_module_register(napi_module* mod) {
-  // NAPI modules always work with the current node version.
-  int module_version = NODE_MODULE_VERSION;
-
-#ifndef EXTERNAL_NAPI
-  if (!node::load_napi_modules) {
-    // NAPI is disabled, so set the module version to -1 to cause the module
-    // to be unloaded.
-    module_version = -1;
-  }
-#endif  // EXTERNAL_NAPI
-
   node::node_module* nm = new node::node_module {
-    module_version,
+    -1,
     mod->nm_flags,
     nullptr,
     mod->nm_filename,
diff --git a/test/addons-napi/test_async/test.js b/test/addons-napi/test_async/test.js
index 749c48e05798a8..34ecae08e67f2e 100644
--- a/test/addons-napi/test_async/test.js
+++ b/test/addons-napi/test_async/test.js
@@ -15,7 +15,7 @@ if (process.argv[2] === 'child') {
   return;
 }
 const p = child_process.spawnSync(
-  process.execPath, [ '--napi-modules', __filename, 'child' ]);
+  process.execPath, [ __filename, 'child' ]);
 assert.ifError(p.error);
 assert.ok(p.stderr.toString().includes(testException));
 
diff --git a/test/addons-napi/test_fatal/test.js b/test/addons-napi/test_fatal/test.js
index aa37dc6803f0d5..7ff9a395635dce 100644
--- a/test/addons-napi/test_fatal/test.js
+++ b/test/addons-napi/test_fatal/test.js
@@ -12,7 +12,7 @@ if (process.argv[2] === 'child') {
 }
 
 const p = child_process.spawnSync(
-    process.execPath, [ '--napi-modules', __filename, 'child' ]);
+  process.execPath, [ __filename, 'child' ]);
 assert.ifError(p.error);
 assert.ok(p.stderr.toString().includes(
-    'FATAL ERROR: test_fatal::Test fatal message'));
+  'FATAL ERROR: test_fatal::Test fatal message'));
diff --git a/test/addons-napi/test_function/test_function.c b/test/addons-napi/test_function/test_function.c
index 77495d9b8a3a46..3e45ad729a4487 100644
--- a/test/addons-napi/test_function/test_function.c
+++ b/test/addons-napi/test_function/test_function.c
@@ -26,7 +26,9 @@ napi_value TestCallFunction(napi_env env, napi_callback_info info) {
   return result;
 }
 
-void TestFunctionName(napi_env env, napi_callback_info info) {}
+napi_value TestFunctionName(napi_env env, napi_callback_info info) {
+  return NULL;
+}
 
 napi_value Init(napi_env env, napi_value exports) {
   napi_value fn1;
diff --git a/test/addons-napi/test_warning/binding.gyp b/test/addons-napi/test_warning/binding.gyp
new file mode 100644
index 00000000000000..a44593e2518c24
--- /dev/null
+++ b/test/addons-napi/test_warning/binding.gyp
@@ -0,0 +1,12 @@
+{
+  "targets": [
+    {
+      "target_name": "test_warning",
+      "sources": [ "test_warning.c" ]
+    },
+    {
+      "target_name": "test_warning2",
+      "sources": [ "test_warning2.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_warning/test.js b/test/addons-napi/test_warning/test.js
new file mode 100644
index 00000000000000..3c5b9222c0e5c2
--- /dev/null
+++ b/test/addons-napi/test_warning/test.js
@@ -0,0 +1,18 @@
+'use strict';
+
+if (process.argv[2] === 'child') {
+  const common = require('../../common');
+  console.log(require(`./build/${common.buildType}/test_warning`));
+  console.log(require(`./build/${common.buildType}/test_warning2`));
+} else {
+  const run = require('child_process').spawnSync;
+  const assert = require('assert');
+  const warning = 'Warning: N-API is an experimental feature and could ' +
+                  'change at any time.';
+
+  const result = run(process.execPath, [__filename, 'child']);
+  assert.deepStrictEqual(result.stdout.toString().match(/\S+/g), ['42', '1337'],
+                         'Modules loaded correctly');
+  assert.deepStrictEqual(result.stderr.toString().split(warning).length, 2,
+                         'Warning was displayed only once');
+}
diff --git a/test/addons-napi/test_warning/test_warning.c b/test/addons-napi/test_warning/test_warning.c
new file mode 100644
index 00000000000000..a152ff84810d28
--- /dev/null
+++ b/test/addons-napi/test_warning/test_warning.c
@@ -0,0 +1,11 @@
+#include <node_api.h>
+#include "../common.h"
+
+napi_value Init(napi_env env, napi_value exports) {
+  napi_value result;
+  NAPI_CALL(env,
+    napi_create_uint32(env, 42, &result));
+  return result;
+}
+
+NAPI_MODULE(test_warning, Init)
diff --git a/test/addons-napi/test_warning/test_warning2.c b/test/addons-napi/test_warning/test_warning2.c
new file mode 100644
index 00000000000000..b35f9071c07ebb
--- /dev/null
+++ b/test/addons-napi/test_warning/test_warning2.c
@@ -0,0 +1,11 @@
+#include <node_api.h>
+#include "../common.h"
+
+napi_value Init(napi_env env, napi_value exports) {
+  napi_value result;
+  NAPI_CALL(env,
+    napi_create_uint32(env, 1337, &result));
+  return result;
+}
+
+NAPI_MODULE(test_warning2, Init)
diff --git a/test/addons-napi/testcfg.py b/test/addons-napi/testcfg.py
index ef7c18fdae8572..b112eb009924fc 100644
--- a/test/addons-napi/testcfg.py
+++ b/test/addons-napi/testcfg.py
@@ -3,4 +3,4 @@
 import testpy
 
 def GetConfiguration(context, root):
-  return testpy.AddonTestConfiguration(context, root, 'addons-napi', ['--napi-modules'])
+  return testpy.AddonTestConfiguration(context, root, 'addons-napi')

From ccc321d724b9a022d9842d162339e825805e0d90 Mon Sep 17 00:00:00 2001
From: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Date: Sun, 17 Sep 2017 23:02:00 +0300
Subject: [PATCH 109/183] doc: fix new nits in links
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/15449
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
---
 doc/api/n-api.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 1d3d00f043bf97..3209346bc17c0b 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -3661,7 +3661,7 @@ NAPI_EXTERN napi_status napi_run_script(napi_env env,
 - `[out] result`: The value resulting from having executed the script.
 
 [Promises]: #n_api_promises
-[Simple Asynchronous Operations]: #n_api_asynchronous_operations
+[Simple Asynchronous Operations]: #n_api_simple_asynchronous_operations
 [Custom Asynchronous Operations]: #n_api_custom_asynchronous_operations
 [Basic N-API Data Types]: #n_api_basic_n_api_data_types
 [ECMAScript Language Specification]: https://tc39.github.io/ecma262/

From 3f8e900d04313904f18cf1ce6bef5888244fd028 Mon Sep 17 00:00:00 2001
From: Sampson Gao <sampsong@ca.ibm.com>
Date: Wed, 20 Sep 2017 17:36:56 -0400
Subject: [PATCH 110/183] n-api: fix warning about size_t compare with int

PR-URL: https://github.com/nodejs/node/pull/15508
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 src/node_api.cc                               | 43 ++++++++++++-------
 src/node_api.h                                |  2 +
 test/addons-napi/test_async/test_async.cc     |  8 ++--
 .../test_constructor/test_constructor.c       |  2 +-
 .../test_conversions/test_conversions.c       |  3 +-
 .../test_env_sharing/compare_env.c            |  3 +-
 test/addons-napi/test_error/test_error.cc     | 28 +++++++-----
 test/addons-napi/test_fatal/test_fatal.c      |  3 +-
 .../addons-napi/test_function/test_function.c |  4 +-
 test/addons-napi/test_general/test_general.c  | 26 +++++++----
 .../addons-napi/test_make_callback/binding.cc |  6 ++-
 .../test_make_callback_recurse/binding.cc     |  3 +-
 .../test_properties/test_properties.c         |  4 +-
 13 files changed, 85 insertions(+), 50 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index b6caca97c0dabe..40e3f0ae4266e4 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -121,16 +121,23 @@ struct napi_env__ {
   CHECK_TO_TYPE((env), Boolean, (context), (result), (src), \
     napi_boolean_expected)
 
+// n-api defines NAPI_AUTO_LENGHTH as the indicator that a string
+// is null terminated. For V8 the equivalent is -1. The assert
+// validates that our cast of NAPI_AUTO_LENGTH results in -1 as
+// needed by V8.
 #define CHECK_NEW_FROM_UTF8_LEN(env, result, str, len)                   \
   do {                                                                   \
+    static_assert(static_cast<int>(NAPI_AUTO_LENGTH) == -1,              \
+                  "Casting NAPI_AUTO_LENGTH to int must result in -1");  \
     auto str_maybe = v8::String::NewFromUtf8(                            \
-        (env)->isolate, (str), v8::NewStringType::kInternalized, (len)); \
+        (env)->isolate, (str), v8::NewStringType::kInternalized,         \
+        static_cast<int>(len));                                          \
     CHECK_MAYBE_EMPTY((env), str_maybe, napi_generic_failure);           \
     (result) = str_maybe.ToLocalChecked();                               \
   } while (0)
 
 #define CHECK_NEW_FROM_UTF8(env, result, str) \
-  CHECK_NEW_FROM_UTF8_LEN((env), (result), (str), -1)
+  CHECK_NEW_FROM_UTF8_LEN((env), (result), (str), NAPI_AUTO_LENGTH)
 
 #define GET_RETURN_STATUS(env)      \
   (!try_catch.HasCaught() ? napi_ok \
@@ -923,21 +930,26 @@ NAPI_NO_RETURN void napi_fatal_error(const char* location,
                                      size_t location_len,
                                      const char* message,
                                      size_t message_len) {
-  char* location_string = const_cast<char*>(location);
-  char* message_string = const_cast<char*>(message);
-  if (location_len != -1) {
-    location_string = reinterpret_cast<char*>(
-        malloc(location_len * sizeof(char) + 1));
-    strncpy(location_string, location, location_len);
-    location_string[location_len] = '\0';
+  std::string location_string;
+  std::string message_string;
+
+  if (location_len != NAPI_AUTO_LENGTH) {
+    location_string.assign(
+        const_cast<char*>(location), location_len);
+  } else {
+    location_string.assign(
+        const_cast<char*>(location), strlen(location));
   }
-  if (message_len != -1) {
-    message_string = reinterpret_cast<char*>(
-        malloc(message_len * sizeof(char) + 1));
-    strncpy(message_string, message, message_len);
-    message_string[message_len] = '\0';
+
+  if (message_len != NAPI_AUTO_LENGTH) {
+    message_string.assign(
+        const_cast<char*>(message), message_len);
+  } else {
+    message_string.assign(
+        const_cast<char*>(message), strlen(message));
   }
-  node::FatalError(location_string, message_string);
+
+  node::FatalError(location_string.c_str(), message_string.c_str());
 }
 
 napi_status napi_create_function(napi_env env,
@@ -3290,7 +3302,6 @@ napi_status napi_adjust_external_memory(napi_env env,
                                         int64_t change_in_bytes,
                                         int64_t* adjusted_value) {
   CHECK_ENV(env);
-  CHECK_ARG(env, &change_in_bytes);
   CHECK_ARG(env, adjusted_value);
 
   *adjusted_value = env->isolate->AdjustAmountOfExternalAllocatedMemory(
diff --git a/src/node_api.h b/src/node_api.h
index 82f2e1900e2fe4..a3a07a64673366 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -100,6 +100,8 @@ typedef struct {
 #define NAPI_MODULE(modname, regfunc) \
   NAPI_MODULE_X(modname, regfunc, NULL, 0)
 
+#define NAPI_AUTO_LENGTH SIZE_MAX
+
 EXTERN_C_START
 
 NAPI_EXTERN void napi_module_register(napi_module* mod);
diff --git a/test/addons-napi/test_async/test_async.cc b/test/addons-napi/test_async/test_async.cc
index 95b061fdf3892f..f135affc0ce7b0 100644
--- a/test/addons-napi/test_async/test_async.cc
+++ b/test/addons-napi/test_async/test_async.cc
@@ -95,8 +95,8 @@ napi_value Test(napi_env env, napi_callback_info info) {
   NAPI_CALL(env,
     napi_create_reference(env, argv[2], 1, &the_carrier._callback));
 
-  NAPI_CALL(env,
-    napi_create_string_utf8(env, "TestResource", -1, &resource_name));
+  NAPI_CALL(env, napi_create_string_utf8(
+      env, "TestResource", NAPI_AUTO_LENGTH, &resource_name));
   NAPI_CALL(env, napi_create_async_work(env, argv[1], resource_name,
     Execute, Complete, &the_carrier, &the_carrier._request));
   NAPI_CALL(env,
@@ -145,8 +145,8 @@ napi_value TestCancel(napi_env env, napi_callback_info info) {
   napi_value resource_name;
   void* data;
 
-  NAPI_CALL(env,
-    napi_create_string_utf8(env, "TestResource", -1, &resource_name));
+  NAPI_CALL(env, napi_create_string_utf8(
+      env, "TestResource", NAPI_AUTO_LENGTH, &resource_name));
 
   // make sure the work we are going to cancel will not be
   // able to start by using all the threads in the pool
diff --git a/test/addons-napi/test_constructor/test_constructor.c b/test/addons-napi/test_constructor/test_constructor.c
index 8b5b4e53ea7bc0..43623d8b60a2ef 100644
--- a/test/addons-napi/test_constructor/test_constructor.c
+++ b/test/addons-napi/test_constructor/test_constructor.c
@@ -77,7 +77,7 @@ napi_value Init(napi_env env, napi_value exports) {
   };
 
   napi_value cons;
-  NAPI_CALL(env, napi_define_class(env, "MyObject", -1, New,
+  NAPI_CALL(env, napi_define_class(env, "MyObject", NAPI_AUTO_LENGTH, New,
       NULL, sizeof(properties)/sizeof(*properties), properties, &cons));
 
   NAPI_CALL(env, napi_create_reference(env, cons, 1, &constructor_));
diff --git a/test/addons-napi/test_conversions/test_conversions.c b/test/addons-napi/test_conversions/test_conversions.c
index 54b1e3678d4ada..9b4d170bb0b689 100644
--- a/test/addons-napi/test_conversions/test_conversions.c
+++ b/test/addons-napi/test_conversions/test_conversions.c
@@ -81,7 +81,8 @@ napi_value AsString(napi_env env, napi_callback_info info) {
     napi_get_value_string_utf8(env, args[0], value, sizeof(value), NULL));
 
   napi_value output;
-  NAPI_CALL(env, napi_create_string_utf8(env, value, -1, &output));
+  NAPI_CALL(env, napi_create_string_utf8(
+      env, value, NAPI_AUTO_LENGTH, &output));
 
   return output;
 }
diff --git a/test/addons-napi/test_env_sharing/compare_env.c b/test/addons-napi/test_env_sharing/compare_env.c
index 39adfb9b713ab3..e9f3e4be5c8e2d 100644
--- a/test/addons-napi/test_env_sharing/compare_env.c
+++ b/test/addons-napi/test_env_sharing/compare_env.c
@@ -15,7 +15,8 @@ napi_value compare(napi_env env, napi_callback_info info) {
 }
 
 napi_value Init(napi_env env, napi_value exports) {
-  NAPI_CALL(env, napi_create_function(env, "exports", -1, compare, NULL, &exports));
+  NAPI_CALL(env, napi_create_function(
+      env, "exports", NAPI_AUTO_LENGTH, compare, NULL, &exports));
   return exports;
 }
 
diff --git a/test/addons-napi/test_error/test_error.cc b/test/addons-napi/test_error/test_error.cc
index 4dd832d673862e..deb571778dd7f9 100644
--- a/test/addons-napi/test_error/test_error.cc
+++ b/test/addons-napi/test_error/test_error.cc
@@ -18,7 +18,8 @@ napi_value checkError(napi_env env, napi_callback_info info) {
 napi_value throwExistingError(napi_env env, napi_callback_info info) {
   napi_value message;
   napi_value error;
-  NAPI_CALL(env, napi_create_string_utf8(env, "existing error", -1, &message));
+  NAPI_CALL(env, napi_create_string_utf8(
+      env, "existing error", NAPI_AUTO_LENGTH, &message));
   NAPI_CALL(env, napi_create_error(env, nullptr,  message, &error));
   NAPI_CALL(env, napi_throw(env, error));
   return nullptr;
@@ -62,7 +63,8 @@ napi_value throwTypeErrorCode(napi_env env, napi_callback_info info) {
 napi_value createError(napi_env env, napi_callback_info info) {
   napi_value result;
   napi_value message;
-  NAPI_CALL(env, napi_create_string_utf8(env, "error", -1, &message));
+  NAPI_CALL(env, napi_create_string_utf8(
+      env, "error", NAPI_AUTO_LENGTH, &message));
   NAPI_CALL(env, napi_create_error(env, nullptr, message, &result));
   return result;
 }
@@ -70,7 +72,8 @@ napi_value createError(napi_env env, napi_callback_info info) {
 napi_value createRangeError(napi_env env, napi_callback_info info) {
   napi_value result;
   napi_value message;
-  NAPI_CALL(env, napi_create_string_utf8(env, "range error", -1, &message));
+  NAPI_CALL(env, napi_create_string_utf8(
+      env, "range error", NAPI_AUTO_LENGTH, &message));
   NAPI_CALL(env, napi_create_range_error(env, nullptr, message, &result));
   return result;
 }
@@ -78,7 +81,8 @@ napi_value createRangeError(napi_env env, napi_callback_info info) {
 napi_value createTypeError(napi_env env, napi_callback_info info) {
   napi_value result;
   napi_value message;
-  NAPI_CALL(env, napi_create_string_utf8(env, "type error", -1, &message));
+  NAPI_CALL(env, napi_create_string_utf8(
+      env, "type error", NAPI_AUTO_LENGTH, &message));
   NAPI_CALL(env, napi_create_type_error(env, nullptr, message, &result));
   return result;
 }
@@ -87,8 +91,10 @@ napi_value createErrorCode(napi_env env, napi_callback_info info) {
   napi_value result;
   napi_value message;
   napi_value code;
-  NAPI_CALL(env, napi_create_string_utf8(env, "Error [error]", -1, &message));
-  NAPI_CALL(env, napi_create_string_utf8(env, "ERR_TEST_CODE", -1, &code));
+  NAPI_CALL(env, napi_create_string_utf8(
+      env, "Error [error]", NAPI_AUTO_LENGTH, &message));
+  NAPI_CALL(env, napi_create_string_utf8(
+      env, "ERR_TEST_CODE", NAPI_AUTO_LENGTH, &code));
   NAPI_CALL(env, napi_create_error(env, code, message, &result));
   return result;
 }
@@ -99,9 +105,10 @@ napi_value createRangeErrorCode(napi_env env, napi_callback_info info) {
   napi_value code;
   NAPI_CALL(env, napi_create_string_utf8(env,
                                          "RangeError [range error]",
-                                         -1,
+                                         NAPI_AUTO_LENGTH,
                                          &message));
-  NAPI_CALL(env, napi_create_string_utf8(env, "ERR_TEST_CODE", -1, &code));
+  NAPI_CALL(env, napi_create_string_utf8(
+      env, "ERR_TEST_CODE", NAPI_AUTO_LENGTH, &code));
   NAPI_CALL(env, napi_create_range_error(env, code, message, &result));
   return result;
 }
@@ -112,9 +119,10 @@ napi_value createTypeErrorCode(napi_env env, napi_callback_info info) {
   napi_value code;
   NAPI_CALL(env, napi_create_string_utf8(env,
                                          "TypeError [type error]",
-                                         -1,
+                                         NAPI_AUTO_LENGTH,
                                          &message));
-  NAPI_CALL(env, napi_create_string_utf8(env, "ERR_TEST_CODE", -1, &code));
+  NAPI_CALL(env, napi_create_string_utf8(
+      env, "ERR_TEST_CODE", NAPI_AUTO_LENGTH, &code));
   NAPI_CALL(env, napi_create_type_error(env, code, message, &result));
   return result;
 }
diff --git a/test/addons-napi/test_fatal/test_fatal.c b/test/addons-napi/test_fatal/test_fatal.c
index 4159fa4b47f567..2059796d99acbd 100644
--- a/test/addons-napi/test_fatal/test_fatal.c
+++ b/test/addons-napi/test_fatal/test_fatal.c
@@ -2,7 +2,8 @@
 #include "../common.h"
 
 napi_value Test(napi_env env, napi_callback_info info) {
-  napi_fatal_error("test_fatal::Test", -1, "fatal message", -1);
+  napi_fatal_error("test_fatal::Test", NAPI_AUTO_LENGTH,
+                   "fatal message", NAPI_AUTO_LENGTH);
   return NULL;
 }
 
diff --git a/test/addons-napi/test_function/test_function.c b/test/addons-napi/test_function/test_function.c
index 3e45ad729a4487..48660ccd0e25ac 100644
--- a/test/addons-napi/test_function/test_function.c
+++ b/test/addons-napi/test_function/test_function.c
@@ -33,11 +33,11 @@ napi_value TestFunctionName(napi_env env, napi_callback_info info) {
 napi_value Init(napi_env env, napi_value exports) {
   napi_value fn1;
   NAPI_CALL(env, napi_create_function(
-      env, NULL, -1, TestCallFunction, NULL, &fn1));
+      env, NULL, NAPI_AUTO_LENGTH, TestCallFunction, NULL, &fn1));
 
   napi_value fn2;
   NAPI_CALL(env, napi_create_function(
-      env, "Name", -1, TestFunctionName, NULL, &fn2));
+      env, "Name", NAPI_AUTO_LENGTH, TestFunctionName, NULL, &fn2));
 
   napi_value fn3;
   NAPI_CALL(env, napi_create_function(
diff --git a/test/addons-napi/test_general/test_general.c b/test/addons-napi/test_general/test_general.c
index 5b909be7a1f1ab..66d2a57c2fd7ea 100644
--- a/test/addons-napi/test_general/test_general.c
+++ b/test/addons-napi/test_general/test_general.c
@@ -43,7 +43,7 @@ napi_value testGetNodeVersion(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_create_uint32(env, node_version->patch, &patch));
   NAPI_CALL(env, napi_create_string_utf8(env,
                                          node_version->release,
-                                         (size_t)-1,
+                                         NAPI_AUTO_LENGTH,
                                          &release));
   NAPI_CALL(env, napi_create_array_with_length(env, 4, &result));
   NAPI_CALL(env, napi_set_element(env, result, 0, major));
@@ -120,21 +120,29 @@ napi_value testNapiTypeof(napi_env env, napi_callback_info info) {
 
   napi_value result = NULL;
   if (argument_type == napi_number) {
-    NAPI_CALL(env, napi_create_string_utf8(env, "number", -1, &result));
+    NAPI_CALL(env, napi_create_string_utf8(
+        env, "number", NAPI_AUTO_LENGTH, &result));
   } else if (argument_type == napi_string) {
-    NAPI_CALL(env, napi_create_string_utf8(env, "string", -1, &result));
+    NAPI_CALL(env, napi_create_string_utf8(
+        env, "string", NAPI_AUTO_LENGTH, &result));
   } else if (argument_type == napi_function) {
-    NAPI_CALL(env, napi_create_string_utf8(env, "function", -1, &result));
+    NAPI_CALL(env, napi_create_string_utf8(
+        env, "function", NAPI_AUTO_LENGTH, &result));
   } else if (argument_type == napi_object) {
-    NAPI_CALL(env, napi_create_string_utf8(env, "object", -1, &result));
+    NAPI_CALL(env, napi_create_string_utf8(
+        env, "object", NAPI_AUTO_LENGTH, &result));
   } else if (argument_type == napi_boolean) {
-    NAPI_CALL(env, napi_create_string_utf8(env, "boolean", -1, &result));
+    NAPI_CALL(env, napi_create_string_utf8(
+        env, "boolean", NAPI_AUTO_LENGTH, &result));
   } else if (argument_type == napi_undefined) {
-    NAPI_CALL(env, napi_create_string_utf8(env, "undefined", -1, &result));
+    NAPI_CALL(env, napi_create_string_utf8(
+        env, "undefined", NAPI_AUTO_LENGTH, &result));
   } else if (argument_type == napi_symbol) {
-    NAPI_CALL(env, napi_create_string_utf8(env, "symbol", -1, &result));
+    NAPI_CALL(env, napi_create_string_utf8(
+        env, "symbol", NAPI_AUTO_LENGTH, &result));
   } else if (argument_type == napi_null) {
-    NAPI_CALL(env, napi_create_string_utf8(env, "null", -1, &result));
+    NAPI_CALL(env, napi_create_string_utf8(
+        env, "null", NAPI_AUTO_LENGTH, &result));
   }
   return result;
 }
diff --git a/test/addons-napi/test_make_callback/binding.cc b/test/addons-napi/test_make_callback/binding.cc
index 18bf46764be40c..18e558aecf8d33 100644
--- a/test/addons-napi/test_make_callback/binding.cc
+++ b/test/addons-napi/test_make_callback/binding.cc
@@ -25,7 +25,8 @@ napi_value MakeCallback(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, func, &func_type));
 
   napi_value resource_name;
-  NAPI_CALL(env, napi_create_string_utf8(env, "test", -1, &resource_name));
+  NAPI_CALL(env, napi_create_string_utf8(
+      env, "test", NAPI_AUTO_LENGTH, &resource_name));
 
   napi_async_context context;
   NAPI_CALL(env, napi_async_init(env, func, resource_name, &context));
@@ -45,7 +46,8 @@ napi_value MakeCallback(napi_env env, napi_callback_info info) {
 
 napi_value Init(napi_env env, napi_value exports) {
   napi_value fn;
-  NAPI_CALL(env, napi_create_function(env, NULL, -1, MakeCallback, NULL, &fn));
+  NAPI_CALL(env, napi_create_function(
+      env, NULL, NAPI_AUTO_LENGTH, MakeCallback, NULL, &fn));
   NAPI_CALL(env, napi_set_named_property(env, exports, "makeCallback", fn));
   return exports;
 }
diff --git a/test/addons-napi/test_make_callback_recurse/binding.cc b/test/addons-napi/test_make_callback_recurse/binding.cc
index ea823294352490..c68e924fdb436d 100644
--- a/test/addons-napi/test_make_callback_recurse/binding.cc
+++ b/test/addons-napi/test_make_callback_recurse/binding.cc
@@ -20,7 +20,8 @@ napi_value MakeCallback(napi_env env, napi_callback_info info) {
 
 napi_value Init(napi_env env, napi_value exports) {
   napi_value fn;
-  NAPI_CALL(env, napi_create_function(env, NULL, -1, MakeCallback, NULL, &fn));
+  NAPI_CALL(env, napi_create_function(
+      env, NULL, NAPI_AUTO_LENGTH, MakeCallback, NULL, &fn));
   NAPI_CALL(env, napi_set_named_property(env, exports, "makeCallback", fn));
   return exports;
 }
diff --git a/test/addons-napi/test_properties/test_properties.c b/test/addons-napi/test_properties/test_properties.c
index da516b6b5acd52..f0442bd0c6fa4b 100644
--- a/test/addons-napi/test_properties/test_properties.c
+++ b/test/addons-napi/test_properties/test_properties.c
@@ -66,14 +66,14 @@ napi_value Init(napi_env env, napi_value exports) {
   napi_value name_value;
   NAPI_CALL(env, napi_create_string_utf8(env,
                                          "NameKeyValue",
-                                         -1,
+                                         NAPI_AUTO_LENGTH,
                                          &name_value));
 
   napi_value symbol_description;
   napi_value name_symbol;
   NAPI_CALL(env, napi_create_string_utf8(env,
                                          "NameKeySymbol",
-                                         -1,
+                                         NAPI_AUTO_LENGTH,
                                          &symbol_description));
   NAPI_CALL(env, napi_create_symbol(env,
                                     symbol_description,

From c683497aeeec6e7647abdf0a5afee43f32e74191 Mon Sep 17 00:00:00 2001
From: rebornix <penn.lv@gmail.com>
Date: Sat, 23 Sep 2017 21:30:28 -0700
Subject: [PATCH 111/183] doc: fix outdated code sample in n-api.md

code samples of napi_create_object and napi_property_descriptor were
not updated to latest API.

PR-URL: https://github.com/nodejs/node/pull/15581
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 doc/api/n-api.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 3209346bc17c0b..2135f78cf9e352 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -2349,7 +2349,7 @@ napi_status status = napi_status_generic_failure;
 
 // const obj = {};
 napi_value obj;
-status = napi_create_obj(env, &obj);
+status = napi_create_object(env, &obj);
 if (status != napi_ok) return status;
 
 // Create napi_values for 123 and 456
@@ -2360,9 +2360,9 @@ status = napi_create_int32(env, 456, &barValue);
 if (status != napi_ok) return status;
 
 // Set the properties
-napi_property_descriptors descriptors[] = {
-  { "foo", fooValue, 0, 0, 0, napi_default, 0 },
-  { "bar", barValue, 0, 0, 0, napi_default, 0 }
+napi_property_descriptor descriptors[] = {
+  { "foo", nullptr, 0, 0, 0, fooValue, napi_default, 0 },
+  { "bar", nullptr, 0, 0, 0, barValue, napi_default, 0 }
 }
 status = napi_define_properties(env,
                                 obj,

From 7e6c9f128cfad6ee964b43ec9d04b96d85c189d8 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Mon, 25 Sep 2017 11:37:18 -0400
Subject: [PATCH 112/183] n-api: add check for large strings

n-api uses size_t for the size of strings when specifying
string lengths.  V8 only supports a size of int.  Add
a check so that an error will be returned if the user
passes in a string with a size larger than will fit into
an int.

PR-URL: https://github.com/nodejs/node/pull/15611
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
---
 src/node_api.cc                            |  7 +++++--
 test/addons-napi/test_string/test.js       |  4 ++++
 test/addons-napi/test_string/test_string.c | 15 +++++++++++++++
 3 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 40e3f0ae4266e4..d7bc67bbcb5b11 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -10,7 +10,7 @@
 
 #include <node_buffer.h>
 #include <node_object_wrap.h>
-
+#include <limits.h>  // INT_MAX
 #include <string.h>
 #include <algorithm>
 #include <cmath>
@@ -129,6 +129,9 @@ struct napi_env__ {
   do {                                                                   \
     static_assert(static_cast<int>(NAPI_AUTO_LENGTH) == -1,              \
                   "Casting NAPI_AUTO_LENGTH to int must result in -1");  \
+    RETURN_STATUS_IF_FALSE((env),                                        \
+        (len == NAPI_AUTO_LENGTH) || len <= INT_MAX,                     \
+        napi_invalid_arg);                                               \
     auto str_maybe = v8::String::NewFromUtf8(                            \
         (env)->isolate, (str), v8::NewStringType::kInternalized,         \
         static_cast<int>(len));                                          \
@@ -871,7 +874,7 @@ void napi_module_register(napi_module* mod) {
 
 // Warning: Keep in-sync with napi_status enum
 const char* error_messages[] = {nullptr,
-                                "Invalid pointer passed as argument",
+                                "Invalid argument",
                                 "An object was expected",
                                 "A string was expected",
                                 "A string or symbol was expected",
diff --git a/test/addons-napi/test_string/test.js b/test/addons-napi/test_string/test.js
index 6e4962d129a6a4..5ce3d739c7a941 100644
--- a/test/addons-napi/test_string/test.js
+++ b/test/addons-napi/test_string/test.js
@@ -69,3 +69,7 @@ assert.strictEqual(test_string.TestUtf8Insufficient(str6), str6.slice(0, 1));
 assert.strictEqual(test_string.TestUtf16Insufficient(str6), str6.slice(0, 3));
 assert.strictEqual(test_string.Utf16Length(str6), 5);
 assert.strictEqual(test_string.Utf8Length(str6), 14);
+
+assert.throws(() => {
+  test_string.TestLargeUtf8();
+}, /^Error: Invalid argument$/);
diff --git a/test/addons-napi/test_string/test_string.c b/test/addons-napi/test_string/test_string.c
index a588b6a1b4e290..01845e428054bc 100644
--- a/test/addons-napi/test_string/test_string.c
+++ b/test/addons-napi/test_string/test_string.c
@@ -1,3 +1,4 @@
+#include <limits.h>  // INT_MAX
 #include <node_api.h>
 #include "../common.h"
 
@@ -201,6 +202,19 @@ napi_value Utf8Length(napi_env env, napi_callback_info info) {
   return output;
 }
 
+napi_value TestLargeUtf8(napi_env env, napi_callback_info info) {
+  napi_value output;
+  if (SIZE_MAX > INT_MAX) {
+    NAPI_CALL(env, napi_create_string_utf8(env, "", ((size_t)INT_MAX) + 1, &output));
+  } else {
+    // just throw the expected error as there is nothing to test
+    // in this case since we can't overflow
+    NAPI_CALL(env, napi_throw_error(env, NULL, "Invalid argument"));
+  }
+
+  return output;
+}
+
 napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor properties[] = {
     DECLARE_NAPI_PROPERTY("TestLatin1", TestLatin1),
@@ -211,6 +225,7 @@ napi_value Init(napi_env env, napi_value exports) {
     DECLARE_NAPI_PROPERTY("TestUtf16Insufficient", TestUtf16Insufficient),
     DECLARE_NAPI_PROPERTY("Utf16Length", Utf16Length),
     DECLARE_NAPI_PROPERTY("Utf8Length", Utf8Length),
+    DECLARE_NAPI_PROPERTY("TestLargeUtf8", TestLargeUtf8),
   };
 
   NAPI_CALL(env, napi_define_properties(

From 1b2c2a904e6a244417f3cfb3d3ef7fbab5cdf70a Mon Sep 17 00:00:00 2001
From: Emily Ford <eford@blackducksoftware.com>
Date: Fri, 6 Oct 2017 10:41:04 -0700
Subject: [PATCH 113/183] test: remove template literal

PR-URL: https://github.com/nodejs/node/pull/15953
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 test/addons-napi/test_error/test.js | 32 +++++++++--------------------
 1 file changed, 10 insertions(+), 22 deletions(-)

diff --git a/test/addons-napi/test_error/test.js b/test/addons-napi/test_error/test.js
index 80f99f48ba79f3..245e734e7503f0 100644
--- a/test/addons-napi/test_error/test.js
+++ b/test/addons-napi/test_error/test.js
@@ -15,46 +15,34 @@ class MyError extends Error { }
 const myError = new MyError('Some MyError');
 
 // Test that native error object is correctly classed
-assert.strictEqual(test_error.checkError(theError), true,
-                   'Error object correctly classed by napi_is_error');
+assert.strictEqual(test_error.checkError(theError), true);
 
 // Test that native type error object is correctly classed
-assert.strictEqual(test_error.checkError(theTypeError), true,
-                   'Type error object correctly classed by napi_is_error');
+assert.strictEqual(test_error.checkError(theTypeError), true);
 
 // Test that native syntax error object is correctly classed
-assert.strictEqual(test_error.checkError(theSyntaxError), true,
-                   'Syntax error object correctly classed by napi_is_error');
+assert.strictEqual(test_error.checkError(theSyntaxError), true);
 
 // Test that native range error object is correctly classed
-assert.strictEqual(test_error.checkError(theRangeError), true,
-                   'Range error object correctly classed by napi_is_error');
+assert.strictEqual(test_error.checkError(theRangeError), true);
 
 // Test that native reference error object is correctly classed
-assert.strictEqual(test_error.checkError(theReferenceError), true,
-                   'Reference error object correctly classed by' +
-                   ' napi_is_error');
+assert.strictEqual(test_error.checkError(theReferenceError), true);
 
 // Test that native URI error object is correctly classed
-assert.strictEqual(test_error.checkError(theURIError), true,
-                   'URI error object correctly classed by napi_is_error');
+assert.strictEqual(test_error.checkError(theURIError), true);
 
 // Test that native eval error object is correctly classed
-assert.strictEqual(test_error.checkError(theEvalError), true,
-                   'Eval error object correctly classed by napi_is_error');
+assert.strictEqual(test_error.checkError(theEvalError), true);
 
 // Test that class derived from native error is correctly classed
-assert.strictEqual(test_error.checkError(myError), true,
-                   'Class derived from native error correctly classed by' +
-                   ' napi_is_error');
+assert.strictEqual(test_error.checkError(myError), true);
 
 // Test that non-error object is correctly classed
-assert.strictEqual(test_error.checkError({}), false,
-                   'Non-error object correctly classed by napi_is_error');
+assert.strictEqual(test_error.checkError({}), false);
 
 // Test that non-error primitive is correctly classed
-assert.strictEqual(test_error.checkError('non-object'), false,
-                   'Non-error primitive correctly classed by napi_is_error');
+assert.strictEqual(test_error.checkError('non-object'), false);
 
 assert.throws(() => {
   test_error.throwExistingError();

From f589058ac49b22428ad3bd282c192b69a67724bf Mon Sep 17 00:00:00 2001
From: Kinnan Kwok <kkwoker@gmail.com>
Date: Fri, 6 Oct 2017 15:23:58 -0400
Subject: [PATCH 114/183] test: fix race condition in addon test

PR-URL: https://github.com/nodejs/node/pull/16037
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Evan Lucas <evanlucas@me.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>
---
 test/addons-napi/test_promise/test.js | 71 +++++++++++----------------
 1 file changed, 30 insertions(+), 41 deletions(-)

diff --git a/test/addons-napi/test_promise/test.js b/test/addons-napi/test_promise/test.js
index 4c2a2e5e76c9fb..e0c8a1a7575bdd 100644
--- a/test/addons-napi/test_promise/test.js
+++ b/test/addons-napi/test_promise/test.js
@@ -4,32 +4,34 @@ const common = require('../../common');
 const test_promise = require(`./build/${common.buildType}/test_promise`);
 const assert = require('assert');
 
-let expected_result, promise;
-
 // A resolution
-expected_result = 42;
-promise = test_promise.createPromise();
-promise.then(
-  common.mustCall(function(result) {
-    assert.strictEqual(result, expected_result,
-                       'promise resolved as expected');
-  }),
-  common.mustNotCall());
-test_promise.concludeCurrentPromise(expected_result, true);
+{
+  const expected_result = 42;
+  const promise = test_promise.createPromise();
+  promise.then(
+    common.mustCall(function(result) {
+      assert.strictEqual(result, expected_result,
+                         `promise resolved as expected, received ${result}`);
+    }),
+    common.mustNotCall());
+  test_promise.concludeCurrentPromise(expected_result, true);
+}
 
 // A rejection
-expected_result = 'It\'s not you, it\'s me.';
-promise = test_promise.createPromise();
-promise.then(
-  common.mustNotCall(),
-  common.mustCall(function(result) {
-    assert.strictEqual(result, expected_result,
-                       'promise rejected as expected');
-  }));
-test_promise.concludeCurrentPromise(expected_result, false);
+{
+  const expected_result = 'It\'s not you, it\'s me.';
+  const promise = test_promise.createPromise();
+  promise.then(
+    common.mustNotCall(),
+    common.mustCall(function(result) {
+      assert.strictEqual(result, expected_result,
+                         `promise rejected as expected, received ${result}`);
+    }));
+  test_promise.concludeCurrentPromise(expected_result, false);
+}
 
 // Chaining
-promise = test_promise.createPromise();
+const promise = test_promise.createPromise();
 promise.then(
   common.mustCall(function(result) {
     assert.strictEqual(result, 'chained answer',
@@ -38,23 +40,10 @@ promise.then(
   common.mustNotCall());
 test_promise.concludeCurrentPromise(Promise.resolve('chained answer'), true);
 
-assert.strictEqual(test_promise.isPromise(promise), true,
-                   'natively created promise is recognized as a promise');
-
-assert.strictEqual(test_promise.isPromise(Promise.reject(-1)), true,
-                   'Promise created with JS is recognized as a promise');
-
-assert.strictEqual(test_promise.isPromise(2.4), false,
-                   'Number is recognized as not a promise');
-
-assert.strictEqual(test_promise.isPromise('I promise!'), false,
-                   'String is recognized as not a promise');
-
-assert.strictEqual(test_promise.isPromise(undefined), false,
-                   'undefined is recognized as not a promise');
-
-assert.strictEqual(test_promise.isPromise(null), false,
-                   'null is recognized as not a promise');
-
-assert.strictEqual(test_promise.isPromise({}), false,
-                   'an object is recognized as not a promise');
+assert.strictEqual(test_promise.isPromise(promise), true);
+assert.strictEqual(test_promise.isPromise(Promise.reject(-1)), true);
+assert.strictEqual(test_promise.isPromise(2.4), false);
+assert.strictEqual(test_promise.isPromise('I promise!'), false);
+assert.strictEqual(test_promise.isPromise(undefined), false);
+assert.strictEqual(test_promise.isPromise(null), false);
+assert.strictEqual(test_promise.isPromise({}), false);

From b225e666db0de62b2d42490aa2306f2d29952486 Mon Sep 17 00:00:00 2001
From: mrgorbo <gourlayjd@linux.com>
Date: Fri, 6 Oct 2017 13:20:05 -0600
Subject: [PATCH 115/183] test: cleaned up assert messages
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/16032
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/addons-napi/test_warning/test.js | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/test/addons-napi/test_warning/test.js b/test/addons-napi/test_warning/test.js
index 3c5b9222c0e5c2..c82008435fd8fd 100644
--- a/test/addons-napi/test_warning/test.js
+++ b/test/addons-napi/test_warning/test.js
@@ -11,8 +11,6 @@ if (process.argv[2] === 'child') {
                   'change at any time.';
 
   const result = run(process.execPath, [__filename, 'child']);
-  assert.deepStrictEqual(result.stdout.toString().match(/\S+/g), ['42', '1337'],
-                         'Modules loaded correctly');
-  assert.deepStrictEqual(result.stderr.toString().split(warning).length, 2,
-                         'Warning was displayed only once');
+  assert.deepStrictEqual(result.stdout.toString().match(/\S+/g), ['42', '1337']);
+  assert.deepStrictEqual(result.stderr.toString().split(warning).length, 2);
 }

From 2e2b48b8988dc17d9fb3ad2011212765b515ead1 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Mon, 9 Oct 2017 12:42:11 +0300
Subject: [PATCH 116/183] n-api: make changes for source compatibility

These changes are necessary in order to retain source compatibility
with older versions of node.

The removal of `module_version` from `napi_module_register()` is
reverted from the flag removal PR, because it should not have been a
part of it.

`CallbackWrapper::NewTarget()` is renamed to
`CallbackWrapper::GetNewTarget()` to distinguish it from V8's native
method, thus allowing for a macro which reduces `NewTarget()` to
`This()` on V8 versions where it was not yet available.

`AsyncResource` is constructed with a C string rather than a V8 string
because the former is available on all versions of node.

PR-URL: https://github.com/nodejs/node/pull/16102
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jason Ginchereau <jasongin@microsoft.com>
---
 src/node_api.cc          | 16 ++++++++++------
 src/node_api_backport.cc |  2 +-
 src/node_api_backport.h  |  2 +-
 3 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index d7bc67bbcb5b11..90ec85e65149dc 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -461,7 +461,7 @@ class CallbackWrapper {
   CallbackWrapper(napi_value this_arg, size_t args_length, void* data)
       : _this(this_arg), _args_length(args_length), _data(data) {}
 
-  virtual napi_value NewTarget() = 0;
+  virtual napi_value GetNewTarget() = 0;
   virtual void Args(napi_value* buffer, size_t bufferlength) = 0;
   virtual void SetReturnValue(napi_value value) = 0;
 
@@ -490,7 +490,7 @@ class CallbackWrapperBase : public CallbackWrapper {
                 ->Value();
   }
 
-  napi_value NewTarget() override { return nullptr; }
+  napi_value GetNewTarget() override { return nullptr; }
 
  protected:
   void InvokeCallback() {
@@ -538,7 +538,7 @@ class FunctionCallbackWrapper
       const v8::FunctionCallbackInfo<v8::Value>& cbinfo)
       : CallbackWrapperBase(cbinfo, cbinfo.Length()) {}
 
-  napi_value NewTarget() override {
+  napi_value GetNewTarget() override {
     if (_cbinfo.IsConstructCall()) {
       return v8impl::JsValueFromV8LocalValue(_cbinfo.NewTarget());
     } else {
@@ -858,8 +858,12 @@ void napi_module_register_cb(v8::Local<v8::Object> exports,
 
 // Registers a NAPI module.
 void napi_module_register(napi_module* mod) {
+  int module_version = -1;
+#ifdef EXTERNAL_NAPI
+  module_version = NODE_MODULE_VERSION;
+#endif  // EXTERNAL_NAPI
   node::node_module* nm = new node::node_module {
-    -1,
+    module_version,
     mod->nm_flags,
     nullptr,
     mod->nm_filename,
@@ -1912,7 +1916,7 @@ napi_status napi_get_new_target(napi_env env,
   v8impl::CallbackWrapper* info =
       reinterpret_cast<v8impl::CallbackWrapper*>(cbinfo);
 
-  *result = info->NewTarget();
+  *result = info->GetNewTarget();
   return napi_clear_last_error(env);
 }
 
@@ -3339,7 +3343,7 @@ class Work : public node::AsyncResource {
                 void* data = nullptr)
     : AsyncResource(env->isolate,
                     async_resource,
-                    async_resource_name),
+                    *v8::String::Utf8Value(async_resource_name)),
     _env(env),
     _data(data),
     _execute(execute),
diff --git a/src/node_api_backport.cc b/src/node_api_backport.cc
index bd2c33242a4af7..655b61da5cf094 100644
--- a/src/node_api_backport.cc
+++ b/src/node_api_backport.cc
@@ -73,7 +73,7 @@ CallbackScope::~CallbackScope() {
 
 AsyncResource::AsyncResource(v8::Isolate* _isolate,
                              v8::Local<v8::Object> _object,
-                             v8::Local<v8::String> name) : isolate(_isolate) {
+                             char* name) : isolate(_isolate) {
   object.Reset(isolate, _object);
 }
 
diff --git a/src/node_api_backport.h b/src/node_api_backport.h
index 9ef12cebd8f677..89ae33d0861529 100644
--- a/src/node_api_backport.h
+++ b/src/node_api_backport.h
@@ -50,7 +50,7 @@ class AsyncResource {
  public:
   AsyncResource(v8::Isolate* _isolate,
                 v8::Local<v8::Object> _object,
-                v8::Local<v8::String> name);
+                char* name);
   ~AsyncResource();
   v8::Isolate* isolate;
   v8::Persistent<v8::Object> object;

From 45205f04bfe681d5b5341e1f12efe75b9f9d0547 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Wed, 11 Oct 2017 16:44:36 +0300
Subject: [PATCH 117/183] n-api,test: use module name macro

test_constructor_name.c should use NODE_GYP_MODULE_NAME.

PR-URL: https://github.com/nodejs/node/pull/16146
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Evan Lucas <evanlucas@me.com>
---
 test/addons-napi/test_constructor/test_constructor_name.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/addons-napi/test_constructor/test_constructor_name.c b/test/addons-napi/test_constructor/test_constructor_name.c
index b178e80f49f489..a5c89791f0f0cd 100644
--- a/test/addons-napi/test_constructor/test_constructor_name.c
+++ b/test/addons-napi/test_constructor/test_constructor_name.c
@@ -20,4 +20,4 @@ napi_value Init(napi_env env, napi_value exports) {
   return cons;
 }
 
-NAPI_MODULE(addon, Init)
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)

From ae88690d1b414e967ed2d2c14d8dd241466d63d3 Mon Sep 17 00:00:00 2001
From: Christina Chan <christina.chan@sap.com>
Date: Fri, 6 Oct 2017 12:38:12 -0700
Subject: [PATCH 118/183] test: remove redundant error messages

Remove redundant error messages for assert.strictEqual()

PR-URL: https://github.com/nodejs/node/pull/16043
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/addons-napi/test_typedarray/test.js | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/test/addons-napi/test_typedarray/test.js b/test/addons-napi/test_typedarray/test.js
index b81295902069b7..25f701f2d30c70 100644
--- a/test/addons-napi/test_typedarray/test.js
+++ b/test/addons-napi/test_typedarray/test.js
@@ -50,10 +50,6 @@ arrayTypes.forEach((currentType) => {
 
   assert.ok(theArray instanceof currentType,
             'Type of new array should match that of the template');
-  assert.notStrictEqual(theArray,
-                        template,
-                        'the new array should not be a copy of the template');
-  assert.strictEqual(theArray.buffer,
-                     buffer,
-                     'Buffer for array should match the one passed in');
+  assert.notStrictEqual(theArray, template);
+  assert.strictEqual(theArray.buffer, buffer);
 });

From 239859f12df300475c6ad516df7b60170aa7aec8 Mon Sep 17 00:00:00 2001
From: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Date: Sat, 14 Oct 2017 17:08:22 +0300
Subject: [PATCH 119/183] doc: fix some links

PR-URL: https://github.com/nodejs/node/pull/16202
Reviewed-By: Daijiro Wachi <daijiro.wachi@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 doc/api/n-api.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 2135f78cf9e352..7156e3760d13f5 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -3680,6 +3680,7 @@ NAPI_EXTERN napi_status napi_run_script(napi_env env,
 [Working with JavaScript Values]: #n_api_working_with_javascript_values
 [Working with JavaScript Values - Abstract Operations]: #n_api_working_with_javascript_values_abstract_operations
 
+[`napi_async_init`]: #n_api_napi_async_init
 [`napi_cancel_async_work`]: #n_api_napi_cancel_async_work
 [`napi_close_escapable_handle_scope`]: #n_api_napi_close_escapable_handle_scope
 [`napi_close_handle_scope`]: #n_api_napi_close_handle_scope

From 6456daf3a3b472fcb78efb84004e4a401c39a9e5 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Fri, 13 Oct 2017 13:11:10 -0400
Subject: [PATCH 120/183] doc: update to use NAPI_AUTO_LENGTH

Update so that doc says to use NAPI_AUTO_LENGTH instead
of -1 to indicate null terminate string.

PR-URL: https://github.com/nodejs/node/pull/16187
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 doc/api/n-api.md | 31 ++++++++++++++++---------------
 1 file changed, 16 insertions(+), 15 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 7156e3760d13f5..a0cd03eae8a8ae 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -551,10 +551,11 @@ NAPI_NO_RETURN void napi_fatal_error(const char* location,
 ```
 
 - `[in] location`: Optional location at which the error occurred.
-- `[in] location_len`: The length of the location in bytes, or -1 if it is
-null-terminated.
+- `[in] location_len`: The length of the location in bytes, or
+NAPI_AUTO_LENGTH if it is null-terminated.
 - `[in] message`: The message associated with the error.
-- `[in] message_len`: The length of the message in bytes, or -1 if it is
+- `[in] message_len`: The length of the message in bytes, or
+NAPI_AUTO_LENGTH if it is
 null-terminated.
 
 The function call does not return, the process will be terminated.
@@ -1256,8 +1257,8 @@ napi_status napi_create_function(napi_env env,
 - `[in] env`: The environment that the API is invoked under.
 - `[in] utf8name`: A string representing the name of the function encoded as
 UTF8.
-- `[in] length`: The length of the utf8name in bytes, or -1 if it is
-null-terminated.
+- `[in] length`: The length of the utf8name in bytes, or
+NAPI_AUTO_LENGTH if it is null-terminated.
 - `[in] cb`: A function pointer to the native function to be invoked when the
 created function is invoked from JavaScript.
 - `[in] data`: Optional arbitrary context data to be passed into the native
@@ -1489,8 +1490,8 @@ napi_status napi_create_string_latin1(napi_env env,
 
 - `[in] env`: The environment that the API is invoked under.
 - `[in] str`: Character buffer representing a ISO-8859-1-encoded string.
-- `[in] length`: The length of the string in bytes, or -1 if it is
-null-terminated.
+- `[in] length`: The length of the string in bytes, or
+NAPI_AUTO_LENGTH if it is null-terminated.
 - `[out] result`: A `napi_value` representing a JavaScript String.
 
 Returns `napi_ok` if the API succeeded.
@@ -1514,8 +1515,8 @@ napi_status napi_create_string_utf16(napi_env env,
 
 - `[in] env`: The environment that the API is invoked under.
 - `[in] str`: Character buffer representing a UTF16-LE-encoded string.
-- `[in] length`: The length of the string in two-byte code units, or -1 if
-it is null-terminated.
+- `[in] length`: The length of the string in two-byte code units, or
+NAPI_AUTO_LENGTH if it is null-terminated.
 - `[out] result`: A `napi_value` representing a JavaScript String.
 
 Returns `napi_ok` if the API succeeded.
@@ -1539,8 +1540,8 @@ napi_status napi_create_string_utf8(napi_env env,
 
 - `[in] env`: The environment that the API is invoked under.
 - `[in] str`: Character buffer representing a UTF8-encoded string.
-- `[in] length`: The length of the string in bytes, or -1 if it is
-null-terminated.
+- `[in] length`: The length of the string in bytes, or NAPI_AUTO_LENGTH
+if it is null-terminated.
 - `[out] result`: A `napi_value` representing a JavaScript String.
 
 Returns `napi_ok` if the API succeeded.
@@ -2304,7 +2305,7 @@ status = napi_create_array(env, &arr);
 if (status != napi_ok) return status;
 
 // Create a napi_value for 'hello'
-status = napi_create_string_utf8(env, "hello", -1, &value);
+status = napi_create_string_utf8(env, "hello", NAPI_AUTO_LENGTH, &value);
 if (status != napi_ok) return status;
 
 // arr[123] = 'hello';
@@ -2993,7 +2994,7 @@ status = napi_get_named_property(env, global, "MyObject", &constructor);
 if (status != napi_ok) return;
 
 // const arg = "hello"
-status = napi_create_string_utf8(env, "hello", -1, &arg);
+status = napi_create_string_utf8(env, "hello", NAPI_AUTO_LENGTH, &arg);
 if (status != napi_ok) return;
 
 napi_value* argv = &arg;
@@ -3040,8 +3041,8 @@ napi_status napi_define_class(napi_env env,
  - `[in] utf8name`: Name of the JavaScript constructor function; this is
    not required to be the same as the C++ class name, though it is recommended
    for clarity.
- - `[in] length`: The length of the utf8name in bytes, or -1 if it is
-null-terminated.
+ - `[in] length`: The length of the utf8name in bytes, or NAPI_AUTO_LENGTH
+if it is null-terminated.
  - `[in] constructor`: Callback function that handles constructing instances
    of the class. (This should be a static method on the class, not an actual
    C++ constructor function.)

From a20e0d53bd32a5db727fe673ea4f70b3ff29a977 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Fri, 13 Oct 2017 12:59:04 -0400
Subject: [PATCH 121/183] n-api: use module name macro

Update tests to use module name macro

PR-URL: https://github.com/nodejs/node/pull/16185
Reviewed-By: Gabriel Schulhof <gabriel.schulhof@intel.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 test/addons-napi/test_warning/test_warning.c  | 2 +-
 test/addons-napi/test_warning/test_warning2.c | 2 +-
 test/addons/openssl-binding/binding.cc        | 2 +-
 test/addons/zlib-binding/binding.cc           | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/addons-napi/test_warning/test_warning.c b/test/addons-napi/test_warning/test_warning.c
index a152ff84810d28..d0821be1f2268d 100644
--- a/test/addons-napi/test_warning/test_warning.c
+++ b/test/addons-napi/test_warning/test_warning.c
@@ -8,4 +8,4 @@ napi_value Init(napi_env env, napi_value exports) {
   return result;
 }
 
-NAPI_MODULE(test_warning, Init)
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
diff --git a/test/addons-napi/test_warning/test_warning2.c b/test/addons-napi/test_warning/test_warning2.c
index b35f9071c07ebb..3c8ee9db01390b 100644
--- a/test/addons-napi/test_warning/test_warning2.c
+++ b/test/addons-napi/test_warning/test_warning2.c
@@ -8,4 +8,4 @@ napi_value Init(napi_env env, napi_value exports) {
   return result;
 }
 
-NAPI_MODULE(test_warning2, Init)
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
diff --git a/test/addons/openssl-binding/binding.cc b/test/addons/openssl-binding/binding.cc
index 582a94478d26ca..fa40b3346a7a39 100644
--- a/test/addons/openssl-binding/binding.cc
+++ b/test/addons/openssl-binding/binding.cc
@@ -29,4 +29,4 @@ inline void Initialize(v8::Local<v8::Object> exports,
 
 }  // anonymous namespace
 
-NODE_MODULE_CONTEXT_AWARE(binding, Initialize)
+NODE_MODULE_CONTEXT_AWARE(NODE_GYP_MODULE_NAME, Initialize)
diff --git a/test/addons/zlib-binding/binding.cc b/test/addons/zlib-binding/binding.cc
index 262f90bf0236e5..a9a8c14306c486 100644
--- a/test/addons/zlib-binding/binding.cc
+++ b/test/addons/zlib-binding/binding.cc
@@ -52,4 +52,4 @@ inline void Initialize(v8::Local<v8::Object> exports,
 
 }  // anonymous namespace
 
-NODE_MODULE_CONTEXT_AWARE(binding, Initialize)
+NODE_MODULE_CONTEXT_AWARE(NODE_GYP_MODULE_NAME, Initialize)

From 96d13340066ff6e7bfff1f92c91ec793e162e2ce Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Sat, 14 Oct 2017 13:02:02 +0200
Subject: [PATCH 122/183] n-api: check against invalid handle scope usage

Fixes: https://github.com/nodejs/node/issues/16175
PR-URL: https://github.com/nodejs/node/pull/16201
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 src/node_api.cc                                   | 15 +++++++++++++++
 src/node_api_types.h                              |  3 ++-
 test/addons-napi/test_handle_scope/test.js        |  6 +-----
 .../test_handle_scope/test_handle_scope.c         |  6 ++++--
 4 files changed, 22 insertions(+), 8 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 90ec85e65149dc..1a2bf75c63b3bc 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -48,6 +48,7 @@ struct napi_env__ {
   v8::Persistent<v8::ObjectTemplate> accessor_data_template;
   bool has_instance_available;
   napi_extended_error_info last_error;
+  int open_handle_scopes = 0;
 };
 
 #define ENV_OBJECT_TEMPLATE(env, prefix, destination, field_count) \
@@ -508,12 +509,16 @@ class CallbackWrapperBase : public CallbackWrapper {
     // Make sure any errors encountered last time we were in N-API are gone.
     napi_clear_last_error(env);
 
+    int open_handle_scopes = env->open_handle_scopes;
+
     napi_value result = cb(env, cbinfo_wrapper);
 
     if (result != nullptr) {
       this->SetReturnValue(result);
     }
 
+    CHECK_EQ(env->open_handle_scopes, open_handle_scopes);
+
     if (!env->last_exception.IsEmpty()) {
       isolate->ThrowException(
           v8::Local<v8::Value>::New(isolate, env->last_exception));
@@ -2587,6 +2592,7 @@ napi_status napi_open_handle_scope(napi_env env, napi_handle_scope* result) {
 
   *result = v8impl::JsHandleScopeFromV8HandleScope(
       new v8impl::HandleScopeWrapper(env->isolate));
+  env->open_handle_scopes++;
   return napi_clear_last_error(env);
 }
 
@@ -2595,7 +2601,11 @@ napi_status napi_close_handle_scope(napi_env env, napi_handle_scope scope) {
   // JS exceptions.
   CHECK_ENV(env);
   CHECK_ARG(env, scope);
+  if (env->open_handle_scopes == 0) {
+    return napi_handle_scope_mismatch;
+  }
 
+  env->open_handle_scopes--;
   delete v8impl::V8HandleScopeFromJsHandleScope(scope);
   return napi_clear_last_error(env);
 }
@@ -2610,6 +2620,7 @@ napi_status napi_open_escapable_handle_scope(
 
   *result = v8impl::JsEscapableHandleScopeFromV8EscapableHandleScope(
       new v8impl::EscapableHandleScopeWrapper(env->isolate));
+  env->open_handle_scopes++;
   return napi_clear_last_error(env);
 }
 
@@ -2620,8 +2631,12 @@ napi_status napi_close_escapable_handle_scope(
   // JS exceptions.
   CHECK_ENV(env);
   CHECK_ARG(env, scope);
+  if (env->open_handle_scopes == 0) {
+    return napi_handle_scope_mismatch;
+  }
 
   delete v8impl::V8EscapableHandleScopeFromJsEscapableHandleScope(scope);
+  env->open_handle_scopes--;
   return napi_clear_last_error(env);
 }
 
diff --git a/src/node_api_types.h b/src/node_api_types.h
index 574cb6ff984f16..230c1f4ae3446f 100644
--- a/src/node_api_types.h
+++ b/src/node_api_types.h
@@ -69,7 +69,8 @@ typedef enum {
   napi_generic_failure,
   napi_pending_exception,
   napi_cancelled,
-  napi_escape_called_twice
+  napi_escape_called_twice,
+  napi_handle_scope_mismatch
 } napi_status;
 
 typedef napi_value (*napi_callback)(napi_env env,
diff --git a/test/addons-napi/test_handle_scope/test.js b/test/addons-napi/test_handle_scope/test.js
index cb687d0bcbf413..53abfe178c8d7d 100644
--- a/test/addons-napi/test_handle_scope/test.js
+++ b/test/addons-napi/test_handle_scope/test.js
@@ -10,11 +10,7 @@ testHandleScope.NewScope();
 
 assert.ok(testHandleScope.NewScopeEscape() instanceof Object);
 
-assert.throws(
-  () => {
-    testHandleScope.NewScopeEscapeTwice();
-  },
-  Error);
+testHandleScope.NewScopeEscapeTwice();
 
 assert.throws(
   () => {
diff --git a/test/addons-napi/test_handle_scope/test_handle_scope.c b/test/addons-napi/test_handle_scope/test_handle_scope.c
index 353a8a44031221..102abb2be612f0 100644
--- a/test/addons-napi/test_handle_scope/test_handle_scope.c
+++ b/test/addons-napi/test_handle_scope/test_handle_scope.c
@@ -33,13 +33,15 @@ napi_value NewScopeEscapeTwice(napi_env env, napi_callback_info info) {
   napi_escapable_handle_scope scope;
   napi_value output = NULL;
   napi_value escapee = NULL;
+  napi_status status;
 
   NAPI_CALL(env, napi_open_escapable_handle_scope(env, &scope));
   NAPI_CALL(env, napi_create_object(env, &output));
   NAPI_CALL(env, napi_escape_handle(env, scope, output, &escapee));
-  NAPI_CALL(env, napi_escape_handle(env, scope, output, &escapee));
+  status = napi_escape_handle(env, scope, output, &escapee);
+  NAPI_ASSERT(env, status == napi_escape_called_twice, "Escaping twice fails");
   NAPI_CALL(env, napi_close_escapable_handle_scope(env, scope));
-  return escapee;
+  return NULL;
 }
 
 napi_value NewScopeWithException(napi_env env, napi_callback_info info) {

From dd2a60ed6a08b1072b3756685d92ca89a97a61f5 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Mon, 16 Oct 2017 15:03:53 +0300
Subject: [PATCH 123/183] n-api: unexpose symbols and remove EXTERNAL_NAPI

* namespaced functions such as v8impl::JsHandleScopeFromV8HandleScope
  become part of Node's public symbols unless they are declared static.
* the class uvimpl::Work needs to be enclosed in an anonymous namespace
  else it, too becomes part of Node's public symbols.
* remove references to EXTERNAL_NAPI.

PR-URL: https://github.com/nodejs/node/pull/16234
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 src/node_api.cc | 61 ++++++++++++++++++++++++++++++-------------------
 1 file changed, 37 insertions(+), 24 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 1a2bf75c63b3bc..f1c13214b3ed96 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -208,19 +208,23 @@ class EscapableHandleScopeWrapper {
   bool escape_called_;
 };
 
+static
 napi_handle_scope JsHandleScopeFromV8HandleScope(HandleScopeWrapper* s) {
   return reinterpret_cast<napi_handle_scope>(s);
 }
 
+static
 HandleScopeWrapper* V8HandleScopeFromJsHandleScope(napi_handle_scope s) {
   return reinterpret_cast<HandleScopeWrapper*>(s);
 }
 
+static
 napi_escapable_handle_scope JsEscapableHandleScopeFromV8EscapableHandleScope(
     EscapableHandleScopeWrapper* s) {
   return reinterpret_cast<napi_escapable_handle_scope>(s);
 }
 
+static
 EscapableHandleScopeWrapper*
 V8EscapableHandleScopeFromJsEscapableHandleScope(
     napi_escapable_handle_scope s) {
@@ -234,18 +238,22 @@ V8EscapableHandleScopeFromJsEscapableHandleScope(
 static_assert(sizeof(v8::Local<v8::Value>) == sizeof(napi_value),
   "Cannot convert between v8::Local<v8::Value> and napi_value");
 
+static
 napi_deferred JsDeferredFromV8Persistent(v8::Persistent<v8::Value>* local) {
   return reinterpret_cast<napi_deferred>(local);
 }
 
+static
 v8::Persistent<v8::Value>* V8PersistentFromJsDeferred(napi_deferred local) {
   return reinterpret_cast<v8::Persistent<v8::Value>*>(local);
 }
 
+static
 napi_value JsValueFromV8LocalValue(v8::Local<v8::Value> local) {
   return reinterpret_cast<napi_value>(*local);
 }
 
+static
 v8::Local<v8::Value> V8LocalValueFromJsValue(napi_value v) {
   v8::Local<v8::Value> local;
   memcpy(&local, &v, sizeof(v));
@@ -648,6 +656,7 @@ class SetterCallbackWrapper
 
 // Creates an object to be made available to the static function callback
 // wrapper, used to retrieve the native callback function and data pointer.
+static
 v8::Local<v8::Object> CreateFunctionCallbackData(napi_env env,
                                                  napi_callback cb,
                                                  void* data) {
@@ -673,6 +682,7 @@ v8::Local<v8::Object> CreateFunctionCallbackData(napi_env env,
 // Creates an object to be made available to the static getter/setter
 // callback wrapper, used to retrieve the native getter/setter callback
 // function and data pointer.
+static
 v8::Local<v8::Object> CreateAccessorCallbackData(napi_env env,
                                                  napi_callback getter,
                                                  napi_callback setter,
@@ -715,6 +725,7 @@ const char napi_wrap_name[] = "N-API Wrapper";
 // Search the object's prototype chain for the wrapper object. Usually the
 // wrapper would be the first in the chain, but it is OK for other objects to
 // be inserted in the prototype chain.
+static
 bool FindWrapper(v8::Local<v8::Object> obj,
                  v8::Local<v8::Object>* result = nullptr,
                  v8::Local<v8::Object>* parent = nullptr) {
@@ -748,6 +759,7 @@ static void DeleteEnv(napi_env env, void* data, void* hint) {
   delete env;
 }
 
+static
 napi_env GetEnv(v8::Local<v8::Context> context) {
   napi_env result;
 
@@ -783,6 +795,7 @@ napi_env GetEnv(v8::Local<v8::Context> context) {
   return result;
 }
 
+static
 napi_status Unwrap(napi_env env,
                    napi_value js_object,
                    void** result,
@@ -806,6 +819,7 @@ napi_status Unwrap(napi_env env,
   return napi_ok;
 }
 
+static
 napi_status ConcludeDeferred(napi_env env,
                              napi_deferred deferred,
                              napi_value result,
@@ -863,12 +877,8 @@ void napi_module_register_cb(v8::Local<v8::Object> exports,
 
 // Registers a NAPI module.
 void napi_module_register(napi_module* mod) {
-  int module_version = -1;
-#ifdef EXTERNAL_NAPI
-  module_version = NODE_MODULE_VERSION;
-#endif  // EXTERNAL_NAPI
   node::node_module* nm = new node::node_module {
-    module_version,
+    -1,
     mod->nm_flags,
     nullptr,
     mod->nm_filename,
@@ -882,6 +892,7 @@ void napi_module_register(napi_module* mod) {
 }
 
 // Warning: Keep in-sync with napi_status enum
+static
 const char* error_messages[] = {nullptr,
                                 "Invalid argument",
                                 "An object was expected",
@@ -1218,10 +1229,10 @@ napi_status napi_delete_property(napi_env env,
   return GET_RETURN_STATUS(env);
 }
 
-NAPI_EXTERN napi_status napi_has_own_property(napi_env env,
-                                              napi_value object,
-                                              napi_value key,
-                                              bool* result) {
+napi_status napi_has_own_property(napi_env env,
+                                  napi_value object,
+                                  napi_value key,
+                                  bool* result) {
   NAPI_PREAMBLE(env);
   CHECK_ARG(env, key);
 
@@ -3332,6 +3343,7 @@ napi_status napi_adjust_external_memory(napi_env env,
   return napi_clear_last_error(env);
 }
 
+namespace {
 namespace uvimpl {
 
 static napi_status ConvertUVErrorCode(int code) {
@@ -3430,6 +3442,7 @@ class Work : public node::AsyncResource {
 };
 
 }  // end of namespace uvimpl
+}  // end of anonymous namespace
 
 #define CALL_UV(env, condition)                                         \
   do {                                                                  \
@@ -3512,9 +3525,9 @@ napi_status napi_cancel_async_work(napi_env env, napi_async_work work) {
   return napi_clear_last_error(env);
 }
 
-NAPI_EXTERN napi_status napi_create_promise(napi_env env,
-                                            napi_deferred* deferred,
-                                            napi_value* promise) {
+napi_status napi_create_promise(napi_env env,
+                                napi_deferred* deferred,
+                                napi_value* promise) {
   NAPI_PREAMBLE(env);
   CHECK_ARG(env, deferred);
   CHECK_ARG(env, promise);
@@ -3531,21 +3544,21 @@ NAPI_EXTERN napi_status napi_create_promise(napi_env env,
   return GET_RETURN_STATUS(env);
 }
 
-NAPI_EXTERN napi_status napi_resolve_deferred(napi_env env,
-                                              napi_deferred deferred,
-                                              napi_value resolution) {
+napi_status napi_resolve_deferred(napi_env env,
+                                  napi_deferred deferred,
+                                  napi_value resolution) {
   return v8impl::ConcludeDeferred(env, deferred, resolution, true);
 }
 
-NAPI_EXTERN napi_status napi_reject_deferred(napi_env env,
-                                             napi_deferred deferred,
-                                             napi_value resolution) {
+napi_status napi_reject_deferred(napi_env env,
+                                 napi_deferred deferred,
+                                 napi_value resolution) {
   return v8impl::ConcludeDeferred(env, deferred, resolution, false);
 }
 
-NAPI_EXTERN napi_status napi_is_promise(napi_env env,
-                                        napi_value promise,
-                                        bool* is_promise) {
+napi_status napi_is_promise(napi_env env,
+                            napi_value promise,
+                            bool* is_promise) {
   CHECK_ENV(env);
   CHECK_ARG(env, promise);
   CHECK_ARG(env, is_promise);
@@ -3555,9 +3568,9 @@ NAPI_EXTERN napi_status napi_is_promise(napi_env env,
   return napi_clear_last_error(env);
 }
 
-NAPI_EXTERN napi_status napi_run_script(napi_env env,
-                                        napi_value script,
-                                        napi_value* result) {
+napi_status napi_run_script(napi_env env,
+                            napi_value script,
+                            napi_value* result) {
   NAPI_PREAMBLE(env);
   CHECK_ARG(env, script);
   CHECK_ARG(env, result);

From e2b58ab4ad5f1c93c412d830066cce7e844df582 Mon Sep 17 00:00:00 2001
From: "Jayson D. Henkel" <jayson.henkel@split-horizon.net>
Date: Fri, 6 Oct 2017 11:51:17 -0700
Subject: [PATCH 124/183] test: improve message for assert.strictEqual()
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/16013
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Evan Lucas <evanlucas@me.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 test/addons-napi/test_exception/test.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/test/addons-napi/test_exception/test.js b/test/addons-napi/test_exception/test.js
index ddd1195fa7234a..b8626b4ddd38a2 100644
--- a/test/addons-napi/test_exception/test.js
+++ b/test/addons-napi/test_exception/test.js
@@ -11,8 +11,7 @@ let caughtError;
 
 // Test that the native side successfully captures the exception
 let returnedError = test_exception.returnException(throwTheError);
-assert.strictEqual(theError, returnedError,
-                   'Returned error is strictly equal to the thrown error');
+assert.strictEqual(theError, returnedError);
 
 // Test that the native side passes the exception through
 assert.throws(

From 6674c17000694bcb26ca2a8da4c40a1c5a628657 Mon Sep 17 00:00:00 2001
From: Matthew Cantelon <me@matthewcantelon.ca>
Date: Fri, 6 Oct 2017 17:26:16 +0000
Subject: [PATCH 125/183] test: include actual value in assertion message

PR-URL: https://github.com/nodejs/node/pull/15935
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
---
 test/addons-napi/test_dataview/test.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/addons-napi/test_dataview/test.js b/test/addons-napi/test_dataview/test.js
index 87cf8159ab8635..711ab01ddb3cb6 100644
--- a/test/addons-napi/test_dataview/test.js
+++ b/test/addons-napi/test_dataview/test.js
@@ -11,4 +11,4 @@ const template = Reflect.construct(DataView, [buffer]);
 
 const theDataview = test_dataview.CreateDataView(template);
 assert.ok(theDataview instanceof DataView,
-          'The new variable should be of type Dataview');
+          `Expect ${theDataview} to be a DataView`);

From ec2c784ae297acf311732789ea61577da167b76f Mon Sep 17 00:00:00 2001
From: John Byrne <troot1@gmail.com>
Date: Mon, 6 Nov 2017 15:03:54 +0000
Subject: [PATCH 126/183] test: use default assertion messages

The string literal messages in addons-napi/test_buffer/test.js are less
helpful than the default messages, so use the default messages.

PR-URL: https://github.com/nodejs/node/pull/16808
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 test/addons-napi/test_buffer/test.js | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/test/addons-napi/test_buffer/test.js b/test/addons-napi/test_buffer/test.js
index 6fb80b02053f9f..713966775df18b 100644
--- a/test/addons-napi/test_buffer/test.js
+++ b/test/addons-napi/test_buffer/test.js
@@ -5,20 +5,17 @@ const common = require('../../common');
 const binding = require(`./build/${common.buildType}/test_buffer`);
 const assert = require('assert');
 
-assert.strictEqual(binding.newBuffer().toString(), binding.theText,
-                   'buffer returned by newBuffer() has wrong contents');
-assert.strictEqual(binding.newExternalBuffer().toString(), binding.theText,
-                   'buffer returned by newExternalBuffer() has wrong contents');
+assert.strictEqual(binding.newBuffer().toString(), binding.theText);
+assert.strictEqual(binding.newExternalBuffer().toString(), binding.theText);
 console.log('gc1');
 global.gc();
 assert.strictEqual(binding.getDeleterCallCount(), 1, 'deleter was not called');
-assert.strictEqual(binding.copyBuffer().toString(), binding.theText,
-                   'buffer returned by copyBuffer() has wrong contents');
+assert.strictEqual(binding.copyBuffer().toString(), binding.theText);
 
 let buffer = binding.staticBuffer();
 assert.strictEqual(binding.bufferHasInstance(buffer), true,
                    'buffer type checking fails');
-assert.strictEqual(binding.bufferInfo(buffer), true, 'buffer data is accurate');
+assert.strictEqual(binding.bufferInfo(buffer), true);
 buffer = null;
 global.gc();
 console.log('gc2');

From 4c8826f4dd5f2242f19b34060eaeae733a89b875 Mon Sep 17 00:00:00 2001
From: Attila Gonda <pcdevil7@gmail.com>
Date: Mon, 6 Nov 2017 15:12:19 +0000
Subject: [PATCH 127/183] test: add detailed message for assertion failure

PR-URL: https://github.com/nodejs/node/pull/16812
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
---
 test/addons-napi/test_typedarray/test.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/addons-napi/test_typedarray/test.js b/test/addons-napi/test_typedarray/test.js
index 25f701f2d30c70..27ef054fe4635e 100644
--- a/test/addons-napi/test_typedarray/test.js
+++ b/test/addons-napi/test_typedarray/test.js
@@ -49,7 +49,9 @@ arrayTypes.forEach((currentType) => {
   const theArray = test_typedarray.CreateTypedArray(template, buffer);
 
   assert.ok(theArray instanceof currentType,
-            'Type of new array should match that of the template');
+            'Type of new array should match that of the template. ' +
+            `Expected type: ${currentType.name}, ` +
+            `actual type: ${template.constructor.name}`);
   assert.notStrictEqual(theArray, template);
   assert.strictEqual(theArray.buffer, buffer);
 });

From cc202a55c2c401669696befcf47699f1e5907c86 Mon Sep 17 00:00:00 2001
From: Paul Blanche <blanchepaule@whiteshoulders.fr>
Date: Mon, 6 Nov 2017 16:27:05 +0100
Subject: [PATCH 128/183] test: improve assert messages in napi exception test

Include unexpected value in assertion messages.

PR-URL: https://github.com/nodejs/node/pull/16820
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 test/addons-napi/test_exception/test.js | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/test/addons-napi/test_exception/test.js b/test/addons-napi/test_exception/test.js
index b8626b4ddd38a2..8bd2f50b12b15f 100644
--- a/test/addons-napi/test_exception/test.js
+++ b/test/addons-napi/test_exception/test.js
@@ -33,7 +33,8 @@ assert.strictEqual(test_exception.wasPending(), true,
 // Test that the native side does not capture a non-existing exception
 returnedError = test_exception.returnException(common.mustCall());
 assert.strictEqual(undefined, returnedError,
-                   'Returned error is undefined when no exception is thrown');
+                   'Returned error should be undefined when no exception is' +
+                   ` thrown, but ${returnedError} was passed`);
 
 // Test that no exception appears that was not thrown by us
 try {
@@ -42,7 +43,8 @@ try {
   caughtError = anError;
 }
 assert.strictEqual(undefined, caughtError,
-                   'No exception originated on the native side');
+                   'No exception originated on the native side, but' +
+                   ` ${caughtError} was passed`);
 
 // Test that the exception state remains clear when no exception is thrown
 assert.strictEqual(test_exception.wasPending(), false,

From bfeeeb329f24cade93aac88dd1db2cae577127cf Mon Sep 17 00:00:00 2001
From: Vipin Menon <vipinmv1@in.ibm.com>
Date: Wed, 8 Nov 2017 12:06:07 +0530
Subject: [PATCH 129/183] doc: fix a typo in n-api documentation

PR-URL: https://github.com/nodejs/node/pull/16879
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
---
 doc/api/n-api.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index a0cd03eae8a8ae..3aaebad44a9914 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -293,7 +293,7 @@ must be called in order to determine if an exception is pending or not.
 
 When an exception is pending one of two approaches can be employed.
 
-The first appoach is to do any appropriate cleanup and then return so that
+The first approach is to do any appropriate cleanup and then return so that
 execution will return to JavaScript. As part of the transition back to
 JavaScript the exception will be thrown at the point in the JavaScript
 code where the native method was invoked. The behavior of most N-API calls

From ab95aa4a66a78c5905a633968bcb688c12024107 Mon Sep 17 00:00:00 2001
From: Paul Ashfield <paul.ashfield@intercity.technology>
Date: Mon, 6 Nov 2017 15:32:35 +0000
Subject: [PATCH 130/183] test: improve error emssage reporting in
 testNapiRun.js

PR-URL: https://github.com/nodejs/node/pull/16821
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
---
 test/addons-napi/test_general/testNapiRun.js | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/test/addons-napi/test_general/testNapiRun.js b/test/addons-napi/test_general/testNapiRun.js
index d7534ecf9c3912..af9f89fa29d53d 100644
--- a/test/addons-napi/test_general/testNapiRun.js
+++ b/test/addons-napi/test_general/testNapiRun.js
@@ -7,6 +7,9 @@ const assert = require('assert');
 // eslint-disable-next-line no-unused-vars
 const addon = require(`./build/${common.buildType}/test_general`);
 
-assert.strictEqual(addon.testNapiRun('(41.92 + 0.08);'), 42,
-                   'napi_run_script() works correctly');
+const testCase = '(41.92 + 0.08);';
+const expected = 42;
+const actual = addon.testNapiRun(testCase);
+
+assert.strictEqual(actual, expected);
 assert.throws(() => addon.testNapiRun({ abc: 'def' }), /string was expected/);

From f3cfc2fe3160247d1a39615169193d387c54ab01 Mon Sep 17 00:00:00 2001
From: Swathi Kalahastri <swkalaha@in.ibm.com>
Date: Fri, 10 Nov 2017 09:14:18 +0530
Subject: [PATCH 131/183] doc: fix typos in N-API
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/16911
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
---
 doc/api/n-api.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 3aaebad44a9914..4a391a6feb05ef 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -1788,7 +1788,7 @@ This API returns the C int32 primitive equivalent
 of the given JavaScript Number. If the number exceeds the range of the
 32 bit integer, then the result is truncated to the equivalent of the
 bottom 32 bits. This can result in a large positive number becoming
-a negative number if the the value is > 2^31 -1.
+a negative number if the value is > 2^31 -1.
 
 #### *napi_get_value_int64*
 <!-- YAML
@@ -3013,7 +3013,7 @@ constructor and methods can be called from JavaScript.
 
  1. The [`napi_define_class`][] API defines a JavaScript class with constructor,
     static properties and methods, and instance properties and methods that
-    correspond to the The C++ class.
+    correspond to the C++ class.
  2. When JavaScript code invokes the constructor, the constructor callback
     uses [`napi_wrap`][] to wrap a new C++ instance in a JavaScript object,
     then returns the wrapper object.

From c15b4eebf945fed302bc273b35bdc19f35c7e740 Mon Sep 17 00:00:00 2001
From: ka3e <loukili.soufiane4z@gmail.com>
Date: Mon, 6 Nov 2017 15:14:51 +0000
Subject: [PATCH 132/183] test: refactor addons-napi/test_promise/test.js

* remove custom messages for assert that conceal values
* add comment explaining test
* add block scoping

PR-URL: https://github.com/nodejs/node/pull/16814
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/addons-napi/test_promise/test.js | 31 +++++++++++++++------------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/test/addons-napi/test_promise/test.js b/test/addons-napi/test_promise/test.js
index e0c8a1a7575bdd..b43ecd87363e44 100644
--- a/test/addons-napi/test_promise/test.js
+++ b/test/addons-napi/test_promise/test.js
@@ -1,8 +1,11 @@
 'use strict';
 
 const common = require('../../common');
-const test_promise = require(`./build/${common.buildType}/test_promise`);
+
+// This tests the promise-related n-api calls
+
 const assert = require('assert');
+const test_promise = require(`./build/${common.buildType}/test_promise`);
 
 // A resolution
 {
@@ -10,8 +13,7 @@ const assert = require('assert');
   const promise = test_promise.createPromise();
   promise.then(
     common.mustCall(function(result) {
-      assert.strictEqual(result, expected_result,
-                         `promise resolved as expected, received ${result}`);
+      assert.strictEqual(result, expected_result);
     }),
     common.mustNotCall());
   test_promise.concludeCurrentPromise(expected_result, true);
@@ -24,23 +26,24 @@ const assert = require('assert');
   promise.then(
     common.mustNotCall(),
     common.mustCall(function(result) {
-      assert.strictEqual(result, expected_result,
-                         `promise rejected as expected, received ${result}`);
+      assert.strictEqual(result, expected_result);
     }));
   test_promise.concludeCurrentPromise(expected_result, false);
 }
 
 // Chaining
-const promise = test_promise.createPromise();
-promise.then(
-  common.mustCall(function(result) {
-    assert.strictEqual(result, 'chained answer',
-                       'resolving with a promise chains properly');
-  }),
-  common.mustNotCall());
-test_promise.concludeCurrentPromise(Promise.resolve('chained answer'), true);
+{
+  const expected_result = 'chained answer';
+  const promise = test_promise.createPromise();
+  promise.then(
+    common.mustCall(function(result) {
+      assert.strictEqual(result, expected_result);
+    }),
+    common.mustNotCall());
+  test_promise.concludeCurrentPromise(Promise.resolve('chained answer'), true);
+}
 
-assert.strictEqual(test_promise.isPromise(promise), true);
+assert.strictEqual(test_promise.isPromise(test_promise.createPromise()), true);
 assert.strictEqual(test_promise.isPromise(Promise.reject(-1)), true);
 assert.strictEqual(test_promise.isPromise(2.4), false);
 assert.strictEqual(test_promise.isPromise('I promise!'), false);

From f450931a6941c0580efe47dbd01af14c846c17b8 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Thu, 2 Nov 2017 18:14:24 -0400
Subject: [PATCH 133/183] doc: document common pattern for instanceof checks

PR-URL: https://github.com/nodejs/node/pull/16699
Fixes: https://github.com/nodejs/node/issues/13824
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 doc/api/n-api.md | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 4a391a6feb05ef..70960fcf6f5495 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -3022,6 +3022,29 @@ constructor and methods can be called from JavaScript.
     callback, [`napi_unwrap`][] obtains the C++ instance that is the target of
     the call.
 
+For wrapped objects it may be difficult to distinguish between a function
+called on a class prototype and a function called on an instance of a class.
+A common pattern used to address this problem is to save a persistent
+reference to the class constructor for later `instanceof` checks.
+
+As an example:
+
+```C
+napi_value MyClass_constructor = nullptr;
+status = napi_get_reference_value(env, MyClass::es_constructor, &MyClass_constructor);
+assert(napi_ok == status);
+bool is_instance = false;
+status = napi_instanceof(env, es_this, MyClass_constructor, &is_instance);
+assert(napi_ok == status);
+if (is_instance) {
+  // napi_unwrap() ...
+} else {
+  // otherwise...
+}
+```
+
+The reference must be freed once it is no longer needed.
+
 ### *napi_define_class*
 <!-- YAML
 added: v8.0.0

From d21b9a5ea4cb31e940d0aa6893879a848a928ca8 Mon Sep 17 00:00:00 2001
From: Anna Henningsen <anna@addaleax.net>
Date: Fri, 17 Nov 2017 22:16:43 +0100
Subject: [PATCH 134/183] n-api: add helper for addons to get the event loop

Add a utility functions for addons to use when they need
a reference to the current event loop.

While the libuv API is not directly part of N-API, it
provides a quite stable C API as well, and is tightly
integrated with Node itself.

As a particular use case, without access to the event loop
it is hard to do something interesting from inside a N-API
finalizer function, since calls into JS and therefore virtually
all other N-API functions are not allowed.

PR-URL: https://github.com/nodejs/node/pull/17109
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 doc/api/n-api.md                      | 17 ++++++++++++++++
 src/node_api.cc                       | 29 ++++++++++++++++++---------
 src/node_api.h                        |  6 ++++++
 src/node_api_backport.cc              |  8 ++++++++
 src/node_api_backport.h               |  2 ++
 test/addons-napi/test_general/test.js |  2 +-
 6 files changed, 54 insertions(+), 10 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 70960fcf6f5495..b31ea3a2688d43 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -3684,6 +3684,23 @@ NAPI_EXTERN napi_status napi_run_script(napi_env env,
 - `[in] script`: A JavaScript string containing the script to execute.
 - `[out] result`: The value resulting from having executed the script.
 
+## libuv event loop
+
+N-API provides a function for getting the current event loop associated with
+a specific `napi_env`.
+
+### napi_get_uv_event_loop
+<!-- YAML
+added: REPLACEME
+-->
+```C
+NAPI_EXTERN napi_status napi_get_uv_event_loop(napi_env env,
+                                               uv_loop_t** loop);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[out] loop`: The current libuv loop instance.
+
 [Promises]: #n_api_promises
 [Simple Asynchronous Operations]: #n_api_simple_asynchronous_operations
 [Custom Asynchronous Operations]: #n_api_custom_asynchronous_operations
diff --git a/src/node_api.cc b/src/node_api.cc
index f1c13214b3ed96..10c8093f5a280b 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -22,7 +22,7 @@
 #include "node_api_backport.h"
 #include "util.h"
 
-#define NAPI_VERSION  1
+#define NAPI_VERSION  2
 
 static
 napi_status napi_set_last_error(napi_env env, napi_status error_code,
@@ -31,8 +31,11 @@ napi_status napi_set_last_error(napi_env env, napi_status error_code,
 static napi_status napi_clear_last_error(napi_env env);
 
 struct napi_env__ {
-  explicit napi_env__(v8::Isolate* _isolate): isolate(_isolate),
-      has_instance_available(true), last_error() {}
+  explicit napi_env__(v8::Isolate* _isolate, uv_loop_t *_loop):
+      isolate(_isolate),
+      has_instance_available(true),
+      last_error(),
+      loop(_loop) {}
   ~napi_env__() {
     last_exception.Reset();
     has_instance.Reset();
@@ -49,6 +52,7 @@ struct napi_env__ {
   bool has_instance_available;
   napi_extended_error_info last_error;
   int open_handle_scopes = 0;
+  uv_loop_t* loop = nullptr;
 };
 
 #define ENV_OBJECT_TEMPLATE(env, prefix, destination, field_count) \
@@ -780,7 +784,7 @@ napi_env GetEnv(v8::Local<v8::Context> context) {
   if (value->IsExternal()) {
     result = static_cast<napi_env>(value.As<v8::External>()->Value());
   } else {
-    result = new napi_env__(isolate);
+    result = new napi_env__(isolate, node::GetCurrentEventLoop(isolate));
     auto external = v8::External::New(isolate, result);
 
     // We must also stop hard if the result of assigning the env to the global
@@ -3494,15 +3498,22 @@ napi_status napi_delete_async_work(napi_env env, napi_async_work work) {
   return napi_clear_last_error(env);
 }
 
+napi_status napi_get_uv_event_loop(napi_env env, uv_loop_t** loop) {
+  CHECK_ENV(env);
+  CHECK_ARG(env, loop);
+  *loop = env->loop;
+  return napi_clear_last_error(env);
+}
+
 napi_status napi_queue_async_work(napi_env env, napi_async_work work) {
   CHECK_ENV(env);
   CHECK_ARG(env, work);
 
-  // Consider: Encapsulate the uv_loop_t into an opaque pointer parameter.
-  // Currently the environment event loop is the same as the UV default loop.
-  // Someday (if node ever supports multiple isolates), it may be better to get
-  // the loop from node::Environment::GetCurrent(env->isolate)->event_loop();
-  uv_loop_t* event_loop = uv_default_loop();
+  napi_status status;
+  uv_loop_t* event_loop = nullptr;
+  status = napi_get_uv_event_loop(env, &event_loop);
+  if (status != napi_ok)
+    return napi_set_last_error(env, status);
 
   uvimpl::Work* w = reinterpret_cast<uvimpl::Work*>(work);
 
diff --git a/src/node_api.h b/src/node_api.h
index a3a07a64673366..8e5eef8a47728f 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -14,6 +14,8 @@
 #include <stdbool.h>
 #include "node_api_types.h"
 
+struct uv_loop_s;  // Forward declaration.
+
 #ifdef _WIN32
   #ifdef BUILDING_NODE_EXTENSION
     #ifdef EXTERNAL_NAPI
@@ -581,6 +583,10 @@ NAPI_EXTERN napi_status napi_run_script(napi_env env,
                                         napi_value script,
                                         napi_value* result);
 
+// Return the current libuv event loop for a given environment
+NAPI_EXTERN napi_status napi_get_uv_event_loop(napi_env env,
+                                               struct uv_loop_s** loop);
+
 EXTERN_C_END
 
 #endif  // SRC_NODE_API_H_
diff --git a/src/node_api_backport.cc b/src/node_api_backport.cc
index 655b61da5cf094..52a0653bfcc591 100644
--- a/src/node_api_backport.cc
+++ b/src/node_api_backport.cc
@@ -71,6 +71,14 @@ CallbackScope::~CallbackScope() {
   env->tick_callback_function()->Call(env->process_object(), 0, nullptr);
 }
 
+uv_loop_t *GetCurrentEventLoop(v8::Isolate *isolate) {
+  HandleScope handle_scope(isolate);
+  auto context = isolate->GetCurrentContext();
+  if (context.IsEmpty())
+    return nullptr;
+  return Environment::GetCurrent(context)->event_loop();
+}
+
 AsyncResource::AsyncResource(v8::Isolate* _isolate,
                              v8::Local<v8::Object> _object,
                              char* name) : isolate(_isolate) {
diff --git a/src/node_api_backport.h b/src/node_api_backport.h
index 89ae33d0861529..968169ef3bd05f 100644
--- a/src/node_api_backport.h
+++ b/src/node_api_backport.h
@@ -31,6 +31,8 @@ class CallbackScope {
   Environment::AsyncCallbackScope callback_scope;
 };
 
+uv_loop_t *GetCurrentEventLoop(v8::Isolate *isolate);
+
 NODE_EXTERN async_context EmitAsyncInit(v8::Isolate* isolate,
                                         v8::Local<v8::Object> resource,
                                         v8::Local<v8::String> name,
diff --git a/test/addons-napi/test_general/test.js b/test/addons-napi/test_general/test.js
index 51ce9563a7196e..10b85ef727bb20 100644
--- a/test/addons-napi/test_general/test.js
+++ b/test/addons-napi/test_general/test.js
@@ -34,7 +34,7 @@ assert.ok(test_general.testGetPrototype(baseObject) !==
 
 // test version management funcitons
 // expected version is currently 1
-assert.strictEqual(test_general.testGetVersion(), 1);
+assert.strictEqual(test_general.testGetVersion(), 2);
 
 const [ major, minor, patch, release ] = test_general.testGetNodeVersion();
 assert.strictEqual(process.version.split('-')[0],

From c04169deac5769c01aeeb75265b52421ca5bdee6 Mon Sep 17 00:00:00 2001
From: neta <neta@netush>
Date: Mon, 20 Nov 2017 21:41:56 +0200
Subject: [PATCH 135/183] src: add napi_handle_scope_mismatch to msg list

PR-URL: https://github.com/nodejs/node/pull/17161
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Refael Ackermann <refack@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Alexey Orlenko <eaglexrlnk@gmail.com>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
---
 src/node_api.cc | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 10c8093f5a280b..9f6d407cfd3ec1 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -909,7 +909,8 @@ const char* error_messages[] = {nullptr,
                                 "Unknown failure",
                                 "An exception is pending",
                                 "The async work item was cancelled",
-                                "napi_escape_handle already called on scope"};
+                                "napi_escape_handle already called on scope",
+                                "Invalid handle scope usage"};
 
 static inline napi_status napi_clear_last_error(napi_env env) {
   env->last_error.error_code = napi_ok;
@@ -940,9 +941,9 @@ napi_status napi_get_last_error_info(napi_env env,
   // We don't have a napi_status_last as this would result in an ABI
   // change each time a message was added.
   static_assert(
-      node::arraysize(error_messages) == napi_escape_called_twice + 1,
+      node::arraysize(error_messages) == napi_handle_scope_mismatch + 1,
       "Count of error messages must match count of error values");
-  CHECK_LE(env->last_error.error_code, napi_escape_called_twice);
+  CHECK_LE(env->last_error.error_code, napi_handle_scope_mismatch);
 
   // Wait until someone requests the last error information to fetch the error
   // message string

From 32dd8f15fba677b626e68cad22dd0b8f0a7dddc5 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Sat, 18 Nov 2017 20:01:57 -0800
Subject: [PATCH 136/183] doc: use "JavaScript" instead of "Javascript"
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/17163
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Alexey Orlenko <eaglexrlnk@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
---
 README.md        | 4 ++--
 doc/api/n-api.md | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/README.md b/README.md
index ad3d838dd58076..cb1a2b7a98bb32 100644
--- a/README.md
+++ b/README.md
@@ -194,8 +194,8 @@ us a report nonetheless.
 
 - [#14519](https://github.com/nodejs/node/issues/14519): _Internal domain
   function can be used to cause segfaults_. Causing program termination using
-  either the public Javascript APIs or the private bindings layer APIs requires
-  the ability to execute arbitrary Javascript code, which is already the highest
+  either the public JavaScript APIs or the private bindings layer APIs requires
+  the ability to execute arbitrary JavaScript code, which is already the highest
   level of privilege possible.
 
 - [#12141](https://github.com/nodejs/node/pull/12141): _buffer: zero fill
diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index b31ea3a2688d43..3c2ce8d14eb080 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -202,7 +202,7 @@ typedef void (*napi_async_complete_callback)(napi_env env,
 ```
 
 ## Error Handling
-N-API uses both return values and Javascript exceptions for error handling.
+N-API uses both return values and JavaScript exceptions for error handling.
 The following sections explain the approach for each case.
 
 ### Return values
@@ -2861,7 +2861,7 @@ Returns `napi_ok` if the API succeeded.
 
 This API allows an add-on author to create a function object in native code.
 This is the primary mechanism to allow calling *into* the add-on's native code
-*from* Javascript.
+*from* JavaScript.
 
 **Note:** The newly created function is not automatically visible from
 script after this call. Instead, a property must be explicitly set on any

From 45a3e6b4d0f27b2e8b4a0470cbd6e3f7261eb49c Mon Sep 17 00:00:00 2001
From: Daniel Bevenius <daniel.bevenius@gmail.com>
Date: Thu, 23 Nov 2017 15:25:14 +0100
Subject: [PATCH 137/183] n-api: use nullptr instead of NULL in node_api.cc
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This commit changes two checks which use NULL to use nullptr.

I'm not very familiar with N-API but wanted to bring this up in case
it was something that was overlooked.

PR-URL: https://github.com/nodejs/node/pull/17276
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
Reviewed-By: Ali Ijaz Sheikh <ofrobots@google.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Lance Ball <lball@redhat.com>
Reviewed-By: Alexey Orlenko <eaglexrlnk@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: MichaëZasso <targos@protonmail.com>
---
 src/node_api.cc | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 9f6d407cfd3ec1..adc1c9c1b48e7d 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -1228,7 +1228,7 @@ napi_status napi_delete_property(napi_env env,
   v8::Maybe<bool> delete_maybe = obj->Delete(context, k);
   CHECK_MAYBE_NOTHING(env, delete_maybe, napi_generic_failure);
 
-  if (result != NULL)
+  if (result != nullptr)
     *result = delete_maybe.FromMaybe(false);
 
   return GET_RETURN_STATUS(env);
@@ -1406,7 +1406,7 @@ napi_status napi_delete_element(napi_env env,
   v8::Maybe<bool> delete_maybe = obj->Delete(context, index);
   CHECK_MAYBE_NOTHING(env, delete_maybe, napi_generic_failure);
 
-  if (result != NULL)
+  if (result != nullptr)
     *result = delete_maybe.FromMaybe(false);
 
   return GET_RETURN_STATUS(env);

From d9dc130a5b4fba425e386289a8d0196799c53e79 Mon Sep 17 00:00:00 2001
From: Franziska Hinkelmann <franzih@chromium.org>
Date: Mon, 4 Dec 2017 18:45:22 +0100
Subject: [PATCH 138/183] doc: update example in module registration

Update return type of `Init` function in documentation to match
`napi_addon_register_func` signature. Return type used to be
`void`, now it is `napi_value`.

PR-URL: https://github.com/nodejs/node/pull/17424
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 doc/api/n-api.md | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 3c2ce8d14eb080..f58f96742eecb3 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -2877,15 +2877,17 @@ napi_value SayHello(napi_env env, napi_callback_info info) {
   return nullptr;
 }
 
-void Init(napi_env env, napi_value exports, napi_value module, void* priv) {
+napi_value Init(napi_env env, napi_value exports) {
   napi_status status;
 
   napi_value fn;
-  status =  napi_create_function(env, NULL, SayHello, NULL, &fn);
-  if (status != napi_ok) return;
+  status =  napi_create_function(env, nullptr, 0, SayHello, nullptr, &fn);
+  if (status != napi_ok) return nullptr;
 
   status = napi_set_named_property(env, exports, "sayHello", fn);
-  if (status != napi_ok) return;
+  if (status != napi_ok) return nullptr;
+
+  return exports;
 }
 
 NAPI_MODULE(addon, Init)

From 3f4ac092d6428470d5f6f4cc41898ffee5ad3292 Mon Sep 17 00:00:00 2001
From: Leko <leko.noor@gmail.com>
Date: Mon, 4 Dec 2017 16:07:45 +0900
Subject: [PATCH 139/183] test: replace assert.throws with common.expectsError

PR-URL: https://github.com/nodejs/node/pull/17445
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/addons-napi/test_error/test.js | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/test/addons-napi/test_error/test.js b/test/addons-napi/test_error/test.js
index 245e734e7503f0..bc2b7a8db75d3e 100644
--- a/test/addons-napi/test_error/test.js
+++ b/test/addons-napi/test_error/test.js
@@ -60,29 +60,26 @@ assert.throws(() => {
   test_error.throwTypeError();
 }, /^TypeError: type error$/);
 
-assert.throws(
+common.expectsError(
   () => test_error.throwErrorCode(),
-  common.expectsError({
+  {
     code: 'ERR_TEST_CODE',
     message: 'Error [error]'
-  })
-);
+  });
 
-assert.throws(
+common.expectsError(
   () => test_error.throwRangeErrorCode(),
-  common.expectsError({
+  {
     code: 'ERR_TEST_CODE',
     message: 'RangeError [range error]'
-  })
-);
+  });
 
-assert.throws(
+common.expectsError(
   () => test_error.throwTypeErrorCode(),
-  common.expectsError({
+  {
     code: 'ERR_TEST_CODE',
     message: 'TypeError [type error]'
-  })
-);
+  });
 
 let error = test_error.createError();
 assert.ok(error instanceof Error, 'expected error to be an instance of Error');

From a005c304c4c50314bff74f7b1d70e2dac6790169 Mon Sep 17 00:00:00 2001
From: babygoat <babygoat1124@gmail.com>
Date: Thu, 23 Nov 2017 19:44:20 +0800
Subject: [PATCH 140/183] test: add unhandled rejection guard

Add an unhandled rejection function in
addons-napi/test_promise/test.js. Also, add a
rejection handler to catch the unhandled rejection
after introducing the guard and test the reason
code.

PR-URL: https://github.com/nodejs/node/pull/17275
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 test/addons-napi/test_promise/test.js | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/test/addons-napi/test_promise/test.js b/test/addons-napi/test_promise/test.js
index b43ecd87363e44..6dc51b3fa558a2 100644
--- a/test/addons-napi/test_promise/test.js
+++ b/test/addons-napi/test_promise/test.js
@@ -7,6 +7,8 @@ const common = require('../../common');
 const assert = require('assert');
 const test_promise = require(`./build/${common.buildType}/test_promise`);
 
+common.crashOnUnhandledRejection();
+
 // A resolution
 {
   const expected_result = 42;
@@ -44,7 +46,14 @@ const test_promise = require(`./build/${common.buildType}/test_promise`);
 }
 
 assert.strictEqual(test_promise.isPromise(test_promise.createPromise()), true);
-assert.strictEqual(test_promise.isPromise(Promise.reject(-1)), true);
+
+const rejectPromise = Promise.reject(-1);
+const expected_reason = -1;
+assert.strictEqual(test_promise.isPromise(rejectPromise), true);
+rejectPromise.catch((reason) => {
+  assert.strictEqual(reason, expected_reason);
+});
+
 assert.strictEqual(test_promise.isPromise(2.4), false);
 assert.strictEqual(test_promise.isPromise('I promise!'), false);
 assert.strictEqual(test_promise.isPromise(undefined), false);

From 2515f516d7fc0e63143662b9418a6e0436b84f67 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Tue, 12 Dec 2017 21:20:47 -0800
Subject: [PATCH 141/183] test: remove literals that obscure assert messages

Remove string literals as messages to `assert.strictEqual()`. They can
be misleading here (where perhaps the reason an assertino failed isn't
that the deleter wasn't called but rather was called too many times.

PR-URL: https://github.com/nodejs/node/pull/17642
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 test/addons-napi/test_buffer/test.js | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/test/addons-napi/test_buffer/test.js b/test/addons-napi/test_buffer/test.js
index 713966775df18b..740b0474a79c60 100644
--- a/test/addons-napi/test_buffer/test.js
+++ b/test/addons-napi/test_buffer/test.js
@@ -9,14 +9,13 @@ assert.strictEqual(binding.newBuffer().toString(), binding.theText);
 assert.strictEqual(binding.newExternalBuffer().toString(), binding.theText);
 console.log('gc1');
 global.gc();
-assert.strictEqual(binding.getDeleterCallCount(), 1, 'deleter was not called');
+assert.strictEqual(binding.getDeleterCallCount(), 1);
 assert.strictEqual(binding.copyBuffer().toString(), binding.theText);
 
 let buffer = binding.staticBuffer();
-assert.strictEqual(binding.bufferHasInstance(buffer), true,
-                   'buffer type checking fails');
+assert.strictEqual(binding.bufferHasInstance(buffer), true);
 assert.strictEqual(binding.bufferInfo(buffer), true);
 buffer = null;
 global.gc();
 console.log('gc2');
-assert.strictEqual(binding.getDeleterCallCount(), 2, 'deleter was not called');
+assert.strictEqual(binding.getDeleterCallCount(), 2);

From 825468fa7cbc382472a25dca533c5140cb4f2a36 Mon Sep 17 00:00:00 2001
From: alnyan <qShadowp@gmail.com>
Date: Sun, 17 Dec 2017 12:22:46 +0200
Subject: [PATCH 142/183] n-api: fix memory leak in napi_async_destroy()

PR-URL: https://github.com/nodejs/node/pull/17714
Reviewed-By: Alexey Orlenko <eaglexrlnk@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Timothy Gu <timothygu99@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 src/node_api.cc | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/node_api.cc b/src/node_api.cc
index adc1c9c1b48e7d..b3334c486edc14 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -2864,6 +2864,8 @@ napi_status napi_async_destroy(napi_env env,
       reinterpret_cast<node::async_context*>(async_context);
   node::EmitAsyncDestroy(isolate, *node_async_context);
 
+  delete node_async_context;
+
   return napi_clear_last_error(env);
 }
 

From 6d5b622ecda6888ae8620462831be586228d3750 Mon Sep 17 00:00:00 2001
From: Nicholas Drane <nicholasdrane@gmail.com>
Date: Thu, 21 Dec 2017 16:48:41 -0600
Subject: [PATCH 143/183] test: remove ambiguous error messages from test_error

assert.strictEqual accepts 3 arguments, the last of which allows for
user-specified error message to be thrown when the assertion fails.
Unfortunately, this error message is less helpful than the default when
it is vague. This commit removes vague, user-specified error messages,
instead relying on clearer, default error messages.

PR-URL: https://github.com/nodejs/node/pull/17812
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 test/addons-napi/test_error/test.js | 46 ++++++++---------------------
 1 file changed, 12 insertions(+), 34 deletions(-)

diff --git a/test/addons-napi/test_error/test.js b/test/addons-napi/test_error/test.js
index bc2b7a8db75d3e..d5c92cb4c3cd2e 100644
--- a/test/addons-napi/test_error/test.js
+++ b/test/addons-napi/test_error/test.js
@@ -83,56 +83,34 @@ common.expectsError(
 
 let error = test_error.createError();
 assert.ok(error instanceof Error, 'expected error to be an instance of Error');
-assert.strictEqual(error.message, 'error', 'expected message to be "error"');
+assert.strictEqual(error.message, 'error');
 
 error = test_error.createRangeError();
 assert.ok(error instanceof RangeError,
           'expected error to be an instance of RangeError');
-assert.strictEqual(error.message,
-                   'range error',
-                   'expected message to be "range error"');
+assert.strictEqual(error.message, 'range error');
 
 error = test_error.createTypeError();
 assert.ok(error instanceof TypeError,
           'expected error to be an instance of TypeError');
-assert.strictEqual(error.message,
-                   'type error',
-                   'expected message to be "type error"');
+assert.strictEqual(error.message, 'type error');
 
 error = test_error.createErrorCode();
 assert.ok(error instanceof Error, 'expected error to be an instance of Error');
-assert.strictEqual(error.code,
-                   'ERR_TEST_CODE',
-                   'expected code to be "ERR_TEST_CODE"');
-assert.strictEqual(error.message,
-                   'Error [error]',
-                   'expected message to be "Error [error]"');
-assert.strictEqual(error.name,
-                   'Error [ERR_TEST_CODE]',
-                   'expected name to be "Error [ERR_TEST_CODE]"');
+assert.strictEqual(error.code, 'ERR_TEST_CODE');
+assert.strictEqual(error.message, 'Error [error]');
+assert.strictEqual(error.name, 'Error [ERR_TEST_CODE]');
 
 error = test_error.createRangeErrorCode();
 assert.ok(error instanceof RangeError,
           'expected error to be an instance of RangeError');
-assert.strictEqual(error.message,
-                   'RangeError [range error]',
-                   'expected message to be "RangeError [range error]"');
-assert.strictEqual(error.code,
-                   'ERR_TEST_CODE',
-                   'expected code to be "ERR_TEST_CODE"');
-assert.strictEqual(error.name,
-                   'RangeError [ERR_TEST_CODE]',
-                   'expected name to be "RangeError[ERR_TEST_CODE]"');
+assert.strictEqual(error.message, 'RangeError [range error]');
+assert.strictEqual(error.code, 'ERR_TEST_CODE');
+assert.strictEqual(error.name, 'RangeError [ERR_TEST_CODE]');
 
 error = test_error.createTypeErrorCode();
 assert.ok(error instanceof TypeError,
           'expected error to be an instance of TypeError');
-assert.strictEqual(error.message,
-                   'TypeError [type error]',
-                   'expected message to be "TypeError [type error]"');
-assert.strictEqual(error.code,
-                   'ERR_TEST_CODE',
-                   'expected code to be "ERR_TEST_CODE"');
-assert.strictEqual(error.name,
-                   'TypeError [ERR_TEST_CODE]',
-                   'expected name to be "TypeError[ERR_TEST_CODE]"');
+assert.strictEqual(error.message, 'TypeError [type error]');
+assert.strictEqual(error.code, 'ERR_TEST_CODE');
+assert.strictEqual(error.name, 'TypeError [ERR_TEST_CODE]');

From 968d7575ad244e1b87159969de0de93c0a7bbb77 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Fri, 5 Jan 2018 12:19:20 -0500
Subject: [PATCH 144/183] doc: updates examples to use NULL
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Examples in the N-API doc used a mix of nullptr and NULL.
We should be consistent and because N-API is a 'C' API I believe
using NULL is better.  This will avoid any potential confusion
as to whether N-API can be used with plain C.

PR-URL: https://github.com/nodejs/node/pull/18008
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
---
 doc/api/n-api.md | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index f58f96742eecb3..86bdecbdff0273 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -903,9 +903,9 @@ napi_value Init(napi_env env, napi_value exports) {
   napi_status status;
   napi_property_descriptor desc =
     {"hello", Method, 0, 0, 0, napi_default, 0};
-  if (status != napi_ok) return nullptr;
+  if (status != napi_ok) return NULL;
   status = napi_define_properties(env, exports, 1, &desc);
-  if (status != napi_ok) return nullptr;
+  if (status != napi_ok) return NULL;
   return exports;
 }
 ```
@@ -917,7 +917,7 @@ napi_value Init(napi_env env, napi_value exports) {
   napi_value method;
   napi_status status;
   status = napi_create_function(env, "exports", Method, NULL, &method));
-  if (status != napi_ok) return nullptr;
+  if (status != napi_ok) return NULL;
   return method;
 }
 ```
@@ -930,21 +930,21 @@ For example, to define a class so that new instances can be created
 napi_value Init(napi_env env, napi_value exports) {
   napi_status status;
   napi_property_descriptor properties[] = {
-    { "value", nullptr, GetValue, SetValue, 0, napi_default, 0 },
+    { "value", NULL, GetValue, SetValue, 0, napi_default, 0 },
     DECLARE_NAPI_METHOD("plusOne", PlusOne),
     DECLARE_NAPI_METHOD("multiply", Multiply),
   };
 
   napi_value cons;
   status =
-      napi_define_class(env, "MyObject", New, nullptr, 3, properties, &cons);
-  if (status != napi_ok) return nullptr;
+      napi_define_class(env, "MyObject", New, NULL, 3, properties, &cons);
+  if (status != napi_ok) return NULL;
 
   status = napi_create_reference(env, cons, 1, &constructor);
-  if (status != napi_ok) return nullptr;
+  if (status != napi_ok) return NULL;
 
   status = napi_set_named_property(env, exports, "MyObject", cons);
-  if (status != napi_ok) return nullptr;
+  if (status != napi_ok) return NULL;
 
   return exports;
 }
@@ -2362,8 +2362,8 @@ if (status != napi_ok) return status;
 
 // Set the properties
 napi_property_descriptor descriptors[] = {
-  { "foo", nullptr, 0, 0, 0, fooValue, napi_default, 0 },
-  { "bar", nullptr, 0, 0, 0, barValue, napi_default, 0 }
+  { "foo", NULL, 0, 0, 0, fooValue, napi_default, 0 },
+  { "bar", NULL, 0, 0, 0, barValue, napi_default, 0 }
 }
 status = napi_define_properties(env,
                                 obj,
@@ -2874,18 +2874,18 @@ object. A sample module might look as follows:
 ```C
 napi_value SayHello(napi_env env, napi_callback_info info) {
   printf("Hello\n");
-  return nullptr;
+  return NULL;
 }
 
 napi_value Init(napi_env env, napi_value exports) {
   napi_status status;
 
   napi_value fn;
-  status =  napi_create_function(env, nullptr, 0, SayHello, nullptr, &fn);
-  if (status != napi_ok) return nullptr;
+  status =  napi_create_function(env, NULL, 0, SayHello, NULL, &fn);
+  if (status != napi_ok) return NULL;
 
   status = napi_set_named_property(env, exports, "sayHello", fn);
-  if (status != napi_ok) return nullptr;
+  if (status != napi_ok) return NULL;
 
   return exports;
 }
@@ -2950,7 +2950,7 @@ napi_status napi_get_new_target(napi_env env,
 Returns `napi_ok` if the API succeeded.
 
 This API returns the `new.target` of the constructor call. If the current
-callback is not a constructor call, the result is `nullptr`.
+callback is not a constructor call, the result is `NULL`.
 
 ### *napi_new_instance*
 <!-- YAML
@@ -3032,7 +3032,7 @@ reference to the class constructor for later `instanceof` checks.
 As an example:
 
 ```C
-napi_value MyClass_constructor = nullptr;
+napi_value MyClass_constructor = NULL;
 status = napi_get_reference_value(env, MyClass::es_constructor, &MyClass_constructor);
 assert(napi_ok == status);
 bool is_instance = false;

From 2f92a075bdb488a597bf77356124055f65f1ff1c Mon Sep 17 00:00:00 2001
From: Jinho Bang <zino@chromium.org>
Date: Tue, 26 Dec 2017 23:20:39 +0900
Subject: [PATCH 145/183] n-api: throw RangeError in napi_create_dataview()
 with invalid range

The API is required that `byte_length + byte_offset` is less than or
equal to the size in bytes of the array passed in. If not, a RangeError
exception is raised[1].

[1] https://nodejs.org/api/n-api.html#n_api_napi_create_dataview

PR-URL: https://github.com/nodejs/node/pull/17869
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 src/node_api.cc                               |  8 +++
 test/addons-napi/test_dataview/test.js        | 22 +++++---
 .../addons-napi/test_dataview/test_dataview.c | 52 ++++++++++++++++++-
 3 files changed, 75 insertions(+), 7 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index b3334c486edc14..54ed3dba887abc 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -3264,6 +3264,14 @@ napi_status napi_create_dataview(napi_env env,
   RETURN_STATUS_IF_FALSE(env, value->IsArrayBuffer(), napi_invalid_arg);
 
   v8::Local<v8::ArrayBuffer> buffer = value.As<v8::ArrayBuffer>();
+  if (byte_length + byte_offset > buffer->ByteLength()) {
+    napi_throw_range_error(
+        env,
+        "ERR_NAPI_INVALID_DATAVIEW_ARGS",
+        "byte_offset + byte_length should be less than or "
+        "equal to the size in bytes of the array passed in");
+    return napi_set_last_error(env, napi_pending_exception);
+  }
   v8::Local<v8::DataView> DataView = v8::DataView::New(buffer, byte_offset,
                                                        byte_length);
 
diff --git a/test/addons-napi/test_dataview/test.js b/test/addons-napi/test_dataview/test.js
index 711ab01ddb3cb6..a6be58494069e5 100644
--- a/test/addons-napi/test_dataview/test.js
+++ b/test/addons-napi/test_dataview/test.js
@@ -5,10 +5,20 @@ const assert = require('assert');
 // Testing api calls for arrays
 const test_dataview = require(`./build/${common.buildType}/test_dataview`);
 
-//create dataview
-const buffer = new ArrayBuffer(128);
-const template = Reflect.construct(DataView, [buffer]);
+// Test for creating dataview
+{
+  const buffer = new ArrayBuffer(128);
+  const template = Reflect.construct(DataView, [buffer]);
 
-const theDataview = test_dataview.CreateDataView(template);
-assert.ok(theDataview instanceof DataView,
-          `Expect ${theDataview} to be a DataView`);
+  const theDataview = test_dataview.CreateDataViewFromJSDataView(template);
+  assert.ok(theDataview instanceof DataView,
+            `Expect ${theDataview} to be a DataView`);
+}
+
+// Test for creating dataview with invalid range
+{
+  const buffer = new ArrayBuffer(128);
+  assert.throws(() => {
+    test_dataview.CreateDataView(buffer, 10, 200);
+  }, RangeError);
+}
diff --git a/test/addons-napi/test_dataview/test_dataview.c b/test/addons-napi/test_dataview/test_dataview.c
index 698ea0bf509856..d65b30efb26a6a 100644
--- a/test/addons-napi/test_dataview/test_dataview.c
+++ b/test/addons-napi/test_dataview/test_dataview.c
@@ -3,6 +3,53 @@
 #include "../common.h"
 
 napi_value CreateDataView(napi_env env, napi_callback_info info) {
+  size_t argc = 3;
+  napi_value args [3];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc == 3, "Wrong number of arguments");
+
+  napi_valuetype valuetype0;
+  napi_value arraybuffer = args[0];
+
+  NAPI_CALL(env, napi_typeof(env, arraybuffer, &valuetype0));
+  NAPI_ASSERT(env, valuetype0 == napi_object,
+              "Wrong type of arguments. Expects a ArrayBuffer as the first "
+              "argument.");
+
+  bool is_arraybuffer;
+  NAPI_CALL(env, napi_is_arraybuffer(env, arraybuffer, &is_arraybuffer));
+  NAPI_ASSERT(env, is_arraybuffer,
+              "Wrong type of arguments. Expects a ArrayBuffer as the first "
+              "argument.");
+
+  napi_valuetype valuetype1;
+  NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
+
+  NAPI_ASSERT(env, valuetype1 == napi_number,
+      "Wrong type of arguments. Expects a number as second argument.");
+
+  size_t byte_offset = 0;
+  NAPI_CALL(env, napi_get_value_uint32(env, args[1], (uint32_t*)(&byte_offset)));
+
+  napi_valuetype valuetype2;
+  NAPI_CALL(env, napi_typeof(env, args[2], &valuetype2));
+
+  NAPI_ASSERT(env, valuetype2 == napi_number,
+      "Wrong type of arguments. Expects a number as third argument.");
+
+  size_t length = 0;
+  NAPI_CALL(env, napi_get_value_uint32(env, args[2], (uint32_t*)(&length)));
+
+  napi_value output_dataview;
+  NAPI_CALL(env,
+            napi_create_dataview(env, length, arraybuffer,
+                                 byte_offset, &output_dataview));
+
+  return output_dataview;
+}
+
+napi_value CreateDataViewFromJSDataView(napi_env env, napi_callback_info info) {
   size_t argc = 1;
   napi_value args [1];
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
@@ -34,12 +81,15 @@ napi_value CreateDataView(napi_env env, napi_callback_info info) {
             napi_create_dataview(env, length, buffer,
                                  byte_offset, &output_dataview));
 
+
   return output_dataview;
 }
 
 napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor descriptors[] = {
-    DECLARE_NAPI_PROPERTY("CreateDataView", CreateDataView)
+    DECLARE_NAPI_PROPERTY("CreateDataView", CreateDataView),
+    DECLARE_NAPI_PROPERTY("CreateDataViewFromJSDataView",
+        CreateDataViewFromJSDataView)
   };
 
   NAPI_CALL(env, napi_define_properties(

From 9dc08ae44a03c70067a2aba2edb29b2dc14d67c1 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Tue, 9 Jan 2018 15:06:28 -0500
Subject: [PATCH 146/183] n-api: expose n-api version in process.versions
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Expose n-api version in process.versions so that it is
available for use in javascript by external modules
like node-pre-gyp. It was previously accessible through
a functon available in the N-API.

PR-URL: https://github.com/nodejs/node/pull/18067
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jeremiah Senkpiel <fishrock123@rocketmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Minwoo Jung <minwoo@nodesource.com>
Reviewed-By: Gibson Fahnestock <gibfahn@gmail.com>
Reviewed-By: Tobias Nießn <tniessen@tnie.de>
Reviewed-By: Richard Lau <riclau@uk.ibm.com>
---
 src/node.cc                            | 6 ++++++
 src/node_api.cc                        | 2 --
 src/node_version.h                     | 3 +++
 test/parallel/test-process-versions.js | 2 +-
 4 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/src/node.cc b/src/node.cc
index 537bc152bcafd1..05f34be823d9cf 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -3198,6 +3198,12 @@ void SetupProcessObject(Environment* env,
       "modules",
       FIXED_ONE_BYTE_STRING(env->isolate(), node_modules_version));
 
+  const char node_napi_version[] = NODE_STRINGIFY(NAPI_VERSION);
+  READONLY_PROPERTY(
+      versions,
+      "napi",
+      FIXED_ONE_BYTE_STRING(env->isolate(), node_napi_version));
+
   // process._promiseRejectEvent
   Local<Object> promiseRejectEvent = Object::New(env->isolate());
   READONLY_DONT_ENUM_PROPERTY(process,
diff --git a/src/node_api.cc b/src/node_api.cc
index 54ed3dba887abc..19b993300d1b00 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -22,8 +22,6 @@
 #include "node_api_backport.h"
 #include "util.h"
 
-#define NAPI_VERSION  2
-
 static
 napi_status napi_set_last_error(napi_env env, napi_status error_code,
                                 uint32_t engine_error_code = 0,
diff --git a/src/node_version.h b/src/node_version.h
index 629a59ec949b0d..843e5b524d533f 100644
--- a/src/node_version.h
+++ b/src/node_version.h
@@ -61,4 +61,7 @@
  */
 #define NODE_MODULE_VERSION 48 /* Node.js v6.0.0 */
 
+// the NAPI_VERSION provided by this version of the runtime
+#define NAPI_VERSION  2
+
 #endif  // SRC_NODE_VERSION_H_
diff --git a/test/parallel/test-process-versions.js b/test/parallel/test-process-versions.js
index b0377afd4a1899..d701a06a46ec10 100644
--- a/test/parallel/test-process-versions.js
+++ b/test/parallel/test-process-versions.js
@@ -3,7 +3,7 @@ const common = require('../common');
 const assert = require('assert');
 
 const expected_keys = ['ares', 'http_parser', 'modules', 'node',
-                       'uv', 'v8', 'zlib'];
+                       'uv', 'v8', 'zlib', 'napi'];
 
 if (common.hasCrypto) {
   expected_keys.push('openssl');

From edb244f3fe38635951788339b75d683279899730 Mon Sep 17 00:00:00 2001
From: Ali Ijaz Sheikh <ofrobots@google.com>
Date: Fri, 12 Jan 2018 10:19:46 -0800
Subject: [PATCH 147/183] doc: napi: fix unbalanced emphasis

Some of the section headers had unbalanced emphasis.

PR-URL: https://github.com/nodejs/node/pull/18122
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Kyle Farnung <kfarnung@microsoft.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 doc/api/n-api.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 86bdecbdff0273..758de94b9f7df6 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -3366,7 +3366,7 @@ scenario, because with those the async execution still happens on the main
 event loop. When using any other async mechanism, the following APIs are
 necessary to ensure an async operation is properly tracked by the runtime.
 
-### *napi_async_init**
+### napi_async_init
 <!-- YAML
 added: REPLACEME
 -->
@@ -3387,7 +3387,7 @@ napi_status napi_async_init(napi_env env,
 
 Returns `napi_ok` if the API succeeded.
 
-### *napi_async_destroy**
+### napi_async_destroy
 <!-- YAML
 added: REPLACEME
 -->
@@ -3401,7 +3401,7 @@ napi_status napi_async_destroy(napi_env env,
 
 Returns `napi_ok` if the API succeeded.
 
-### *napi_make_callback*
+### napi_make_callback
 <!-- YAML
 added: v8.0.0
 changes:

From 85b964bbb072a34cbb1be290201ad331eb607a2a Mon Sep 17 00:00:00 2001
From: Ali Ijaz Sheikh <ofrobots@google.com>
Date: Fri, 12 Jan 2018 10:25:02 -0800
Subject: [PATCH 148/183] doc: napi: make header style consistent

Some of the API section headers had emphasis, while others did not.
Use a consistent style (no emphasis) for all of them, as that matches
our other API docs.

PR-URL: https://github.com/nodejs/node/pull/18122
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Kyle Farnung <kfarnung@microsoft.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 doc/api/n-api.md | 176 +++++++++++++++++++++++------------------------
 1 file changed, 88 insertions(+), 88 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 758de94b9f7df6..9fc99759101489 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -69,7 +69,7 @@ N-API exposes the following fundamental datatypes as abstractions that are
 consumed by the various APIs. These APIs should be treated as opaque,
 introspectable only with other N-API calls.
 
-### *napi_status*
+### napi_status
 Integral status code indicating the success or failure of a N-API call.
 Currently, the following status codes are supported.
 ```C
@@ -92,7 +92,7 @@ typedef enum {
 If additional information is required upon an API returning a failed status,
 it can be obtained by calling `napi_get_last_error_info`.
 
-### *napi_extended_error_info*
+### napi_extended_error_info
 ```C
 typedef struct {
   const char* error_message;
@@ -112,7 +112,7 @@ typedef struct {
 
 See the [Error Handling][] section for additional information.
 
-### *napi_env*
+### napi_env
 `napi_env` is used to represent a context that the underlying N-API
 implementation can use to persist VM-specific state. This structure is passed
 to native functions when they're invoked, and it must be passed back when
@@ -121,11 +121,11 @@ the initial native function was called must be passed to any subsequent
 nested N-API calls. Caching the `napi_env` for the purpose of general reuse is
 not allowed.
 
-### *napi_value*
+### napi_value
 This is an opaque pointer that is used to represent a JavaScript value.
 
 ### N-API Memory Management types
-#### *napi_handle_scope*
+#### napi_handle_scope
 This is an abstraction used to control and modify the lifetime of objects
 created within a particular scope. In general, N-API values are created within
 the context of a handle scope. When a native method is called from
@@ -143,11 +143,11 @@ referenced from the current stack frame.
 
 For more details, review the [Object Lifetime Management][].
 
-#### *napi_escapable_handle_scope*
+#### napi_escapable_handle_scope
 Escapable handle scopes are a special type of handle scope to return values
 created within a particular handle scope to a parent scope.
 
-#### *napi_ref*
+#### napi_ref
 This is the abstraction to use to reference a `napi_value`. This allows for
 users to manage the lifetimes of JavaScript values, including defining their
 minimum lifetimes explicitly.
@@ -155,12 +155,12 @@ minimum lifetimes explicitly.
 For more details, review the [Object Lifetime Management][].
 
 ### N-API Callback types
-#### *napi_callback_info*
+#### napi_callback_info
 Opaque datatype that is passed to a callback function. It can be used for
 getting additional information about the context in which the callback was
 invoked.
 
-#### *napi_callback*
+#### napi_callback
 Function pointer type for user-provided native functions which are to be
 exposed to JavaScript via N-API. Callback functions should satisfy the
 following signature:
@@ -168,7 +168,7 @@ following signature:
 typedef napi_value (*napi_callback)(napi_env, napi_callback_info);
 ```
 
-#### *napi_finalize*
+#### napi_finalize
 Function pointer type for add-on provided functions that allow the user to be
 notified when externally-owned data is ready to be cleaned up because the
 object with which it was associated with, has been garbage-collected. The user
@@ -974,7 +974,7 @@ However, for better performance, it's better for the caller to make sure that
 the `napi_value` in question is of the JavaScript type expected by the API.
 
 ### Enum types
-#### *napi_valuetype*
+#### napi_valuetype
 ```C
 typedef enum {
   // ES6 types (corresponds to typeof)
@@ -997,7 +997,7 @@ the ECMAScript Language Specification.
 In addition to types in that section, `napi_valuetype` can also represent
 Functions and Objects with external data.
 
-#### *napi_typedarray_type*
+#### napi_typedarray_type
 ```C
 typedef enum {
   napi_int8_array,
@@ -1018,7 +1018,7 @@ Elements of this enum correspond to
 of the [ECMAScript Language Specification][].
 
 ### Object Creation Functions
-#### *napi_create_array*
+#### napi_create_array
 <!-- YAML
 added: v8.0.0
 -->
@@ -1036,7 +1036,7 @@ JavaScript arrays are described in
 [Section 22.1](https://tc39.github.io/ecma262/#sec-array-objects) of the
 ECMAScript Language Specification.
 
-#### *napi_create_array_with_length*
+#### napi_create_array_with_length
 <!-- YAML
 added: v8.0.0
 -->
@@ -1065,7 +1065,7 @@ JavaScript arrays are described in
 [Section 22.1](https://tc39.github.io/ecma262/#sec-array-objects) of the
 ECMAScript Language Specification.
 
-#### *napi_create_arraybuffer*
+#### napi_create_arraybuffer
 <!-- YAML
 added: v8.0.0
 -->
@@ -1097,7 +1097,7 @@ JavaScript ArrayBuffer objects are described in
 [Section 24.1](https://tc39.github.io/ecma262/#sec-arraybuffer-objects)
 of the ECMAScript Language Specification.
 
-#### *napi_create_buffer*
+#### napi_create_buffer
 <!-- YAML
 added: v8.0.0
 -->
@@ -1118,7 +1118,7 @@ Returns `napi_ok` if the API succeeded.
 This API allocates a `node::Buffer` object. While this is still a
 fully-supported data structure, in most cases using a TypedArray will suffice.
 
-#### *napi_create_buffer_copy*
+#### napi_create_buffer_copy
 <!-- YAML
 added: v8.0.0
 -->
@@ -1143,7 +1143,7 @@ This API allocates a `node::Buffer` object and initializes it with data copied
 from the passed-in buffer. While this is still a fully-supported data
 structure, in most cases using a TypedArray will suffice.
 
-#### *napi_create_external*
+#### napi_create_external
 <!-- YAML
 added: v8.0.0
 -->
@@ -1210,7 +1210,7 @@ JavaScript ArrayBuffers are described in
 [Section 24.1](https://tc39.github.io/ecma262/#sec-arraybuffer-objects)
 of the ECMAScript Language Specification.
 
-#### *napi_create_external_buffer*
+#### napi_create_external_buffer
 <!-- YAML
 added: v8.0.0
 -->
@@ -1241,7 +1241,7 @@ structure, in most cases using a TypedArray will suffice.
 
 **Note:** For Node.js >=4 `Buffers` are Uint8Arrays.
 
-#### *napi_create_function*
+#### napi_create_function
 <!-- YAML
 added: v8.0.0
 -->
@@ -1274,7 +1274,7 @@ JavaScript Functions are described in
 [Section 19.2](https://tc39.github.io/ecma262/#sec-function-objects)
 of the ECMAScript Language Specification.
 
-#### *napi_create_object*
+#### napi_create_object
 <!-- YAML
 added: v8.0.0
 -->
@@ -1294,7 +1294,7 @@ The JavaScript Object type is described in
 [Section 6.1.7](https://tc39.github.io/ecma262/#sec-object-type) of the
 ECMAScript Language Specification.
 
-#### *napi_create_symbol*
+#### napi_create_symbol
 <!-- YAML
 added: v8.0.0
 -->
@@ -1317,7 +1317,7 @@ The JavaScript Symbol type is described in
 [Section 19.4](https://tc39.github.io/ecma262/#sec-symbol-objects)
 of the ECMAScript Language Specification.
 
-#### *napi_create_typedarray*
+#### napi_create_typedarray
 <!-- YAML
 added: v8.0.0
 -->
@@ -1353,7 +1353,7 @@ JavaScript TypedArray Objects are described in
 of the ECMAScript Language Specification.
 
 
-#### *napi_create_dataview*
+#### napi_create_dataview
 <!-- YAML
 added: REPLACEME
 -->
@@ -1387,7 +1387,7 @@ JavaScript DataView Objects are described in
 [Section 24.3][] of the ECMAScript Language Specification.
 
 ### Functions to convert from C types to N-API
-#### *napi_create_int32*
+#### napi_create_int32
 <!-- YAML
 added: REPLACEME
 -->
@@ -1408,7 +1408,7 @@ The JavaScript Number type is described in
 [Section 6.1.6](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type)
 of the ECMAScript Language Specification.
 
-#### *napi_create_uint32*
+#### napi_create_uint32
 <!-- YAML
 added: REPLACEME
 -->
@@ -1429,7 +1429,7 @@ The JavaScript Number type is described in
 [Section 6.1.6](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type)
 of the ECMAScript Language Specification.
 
-#### *napi_create_int64*
+#### napi_create_int64
 <!-- YAML
 added: REPLACEME
 -->
@@ -1456,7 +1456,7 @@ outside the range of
 [`Number.MAX_SAFE_INTEGER`](https://tc39.github.io/ecma262/#sec-number.max_safe_integer)
 (2^53 - 1) will lose precision.
 
-#### *napi_create_double*
+#### napi_create_double
 <!-- YAML
 added: REPLACEME
 -->
@@ -1477,7 +1477,7 @@ The JavaScript Number type is described in
 [Section 6.1.6](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-number-type)
 of the ECMAScript Language Specification.
 
-#### *napi_create_string_latin1*
+#### napi_create_string_latin1
 <!-- YAML
 added: v8.0.0
 -->
@@ -1502,7 +1502,7 @@ The JavaScript String type is described in
 [Section 6.1.4](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type)
 of the ECMAScript Language Specification.
 
-#### *napi_create_string_utf16*
+#### napi_create_string_utf16
 <!-- YAML
 added: v8.0.0
 -->
@@ -1527,7 +1527,7 @@ The JavaScript String type is described in
 [Section 6.1.4](https://tc39.github.io/ecma262/#sec-ecmascript-language-types-string-type)
 of the ECMAScript Language Specification.
 
-#### *napi_create_string_utf8*
+#### napi_create_string_utf8
 <!-- YAML
 added: v8.0.0
 -->
@@ -1553,7 +1553,7 @@ The JavaScript String type is described in
 of the ECMAScript Language Specification.
 
 ### Functions to convert from N-API to C types
-#### *napi_get_array_length*
+#### napi_get_array_length
 <!-- YAML
 added: v8.0.0
 -->
@@ -1576,7 +1576,7 @@ Array length is described in
 [Section 22.1.4.1](https://tc39.github.io/ecma262/#sec-properties-of-array-instances-length)
 of the ECMAScript Language Specification.
 
-#### *napi_get_arraybuffer_info*
+#### napi_get_arraybuffer_info
 <!-- YAML
 added: v8.0.0
 -->
@@ -1604,7 +1604,7 @@ which can be used to guarantee control over the lifetime of the
 ArrayBuffer. It's also safe to use the returned data buffer within the same
 callback as long as there are no calls to other APIs that might trigger a GC.
 
-#### *napi_get_buffer_info*
+#### napi_get_buffer_info
 <!-- YAML
 added: v8.0.0
 -->
@@ -1628,7 +1628,7 @@ and it's length.
 *Warning*: Use caution while using this API since the underlying data buffer's
 lifetime is not guaranteed if it's managed by the VM.
 
-#### *napi_get_prototype*
+#### napi_get_prototype
 <!-- YAML
 added: v8.0.0
 -->
@@ -1646,7 +1646,7 @@ not the same as the function's `prototype` property).
 
 Returns `napi_ok` if the API succeeded.
 
-#### *napi_get_typedarray_info*
+#### napi_get_typedarray_info
 <!-- YAML
 added: v8.0.0
 -->
@@ -1678,7 +1678,7 @@ is managed by the VM
 
 
 
-#### *napi_get_dataview_info*
+#### napi_get_dataview_info
 <!-- YAML
 added: REPLACEME
 -->
@@ -1706,7 +1706,7 @@ Returns `napi_ok` if the API succeeded.
 This API returns various properties of a DataView.
 
 
-#### *napi_get_value_bool*
+#### napi_get_value_bool
 <!-- YAML
 added: v8.0.0
 -->
@@ -1725,7 +1725,7 @@ passed in it returns `napi_boolean_expected`.
 This API returns the C boolean primitive equivalent of the given JavaScript
 Boolean.
 
-#### *napi_get_value_double*
+#### napi_get_value_double
 <!-- YAML
 added: v8.0.0
 -->
@@ -1747,7 +1747,7 @@ This API returns the C double primitive equivalent of the given JavaScript
 Number.
 
 
-#### *napi_get_value_external*
+#### napi_get_value_external
 <!-- YAML
 added: v8.0.0
 -->
@@ -1767,7 +1767,7 @@ passed in it returns `napi_invalid_arg`.
 This API retrieves the external data pointer that was previously passed to
 `napi_create_external()`.
 
-#### *napi_get_value_int32*
+#### napi_get_value_int32
 <!-- YAML
 added: v8.0.0
 -->
@@ -1790,7 +1790,7 @@ of the given JavaScript Number. If the number exceeds the range of the
 bottom 32 bits. This can result in a large positive number becoming
 a negative number if the value is > 2^31 -1.
 
-#### *napi_get_value_int64*
+#### napi_get_value_int64
 <!-- YAML
 added: v8.0.0
 -->
@@ -1810,7 +1810,7 @@ is passed in it returns `napi_number_expected`.
 This API returns the C int64 primitive equivalent of the given
 JavaScript Number
 
-#### *napi_get_value_string_latin1*
+#### napi_get_value_string_latin1
 <!-- YAML
 added: v8.0.0
 -->
@@ -1837,7 +1837,7 @@ is passed in it returns `napi_string_expected`.
 This API returns the ISO-8859-1-encoded string corresponding the value passed
 in.
 
-#### *napi_get_value_string_utf8*
+#### napi_get_value_string_utf8
 <!-- YAML
 added: v8.0.0
 -->
@@ -1863,7 +1863,7 @@ is passed in it returns `napi_string_expected`.
 
 This API returns the UTF8-encoded string corresponding the value passed in.
 
-#### *napi_get_value_string_utf16*
+#### napi_get_value_string_utf16
 <!-- YAML
 added: v8.0.0
 -->
@@ -1889,7 +1889,7 @@ is passed in it returns `napi_string_expected`.
 
 This API returns the UTF16-encoded string corresponding the value passed in.
 
-#### *napi_get_value_uint32*
+#### napi_get_value_uint32
 <!-- YAML
 added: v8.0.0
 -->
@@ -1911,7 +1911,7 @@ This API returns the C primitive equivalent of the given `napi_value` as a
 `uint32_t`.
 
 ### Functions to get global instances
-#### *napi_get_boolean*
+#### napi_get_boolean
 <!-- YAML
 added: v8.0.0
 -->
@@ -1929,7 +1929,7 @@ Returns `napi_ok` if the API succeeded.
 This API is used to return the JavaScript singleton object that is used to
 represent the given boolean value
 
-#### *napi_get_global*
+#### napi_get_global
 <!-- YAML
 added: v8.0.0
 -->
@@ -1944,7 +1944,7 @@ Returns `napi_ok` if the API succeeded.
 
 This API returns the global Object.
 
-#### *napi_get_null*
+#### napi_get_null
 <!-- YAML
 added: v8.0.0
 -->
@@ -1959,7 +1959,7 @@ Returns `napi_ok` if the API succeeded.
 
 This API returns the null Object.
 
-#### *napi_get_undefined*
+#### napi_get_undefined
 <!-- YAML
 added: v8.0.0
 -->
@@ -1987,7 +1987,7 @@ These APIs support doing one of the following:
 2. Check the type of a JavaScript value
 3. Check for equality between two JavaScript values
 
-### *napi_coerce_to_bool*
+### napi_coerce_to_bool
 <!-- YAML
 added: v8.0.0
 -->
@@ -2008,7 +2008,7 @@ This API implements the abstract operation ToBoolean as defined in
 of the ECMAScript Language Specification.
 This API can be re-entrant if getters are defined on the passed-in Object.
 
-### *napi_coerce_to_number*
+### napi_coerce_to_number
 <!-- YAML
 added: v8.0.0
 -->
@@ -2029,7 +2029,7 @@ This API implements the abstract operation ToNumber as defined in
 of the ECMAScript Language Specification.
 This API can be re-entrant if getters are defined on the passed-in Object.
 
-### *napi_coerce_to_object*
+### napi_coerce_to_object
 <!-- YAML
 added: v8.0.0
 -->
@@ -2050,7 +2050,7 @@ This API implements the abstract operation ToObject as defined in
 of the ECMAScript Language Specification.
 This API can be re-entrant if getters are defined on the passed-in Object.
 
-### *napi_coerce_to_string*
+### napi_coerce_to_string
 <!-- YAML
 added: v8.0.0
 -->
@@ -2071,7 +2071,7 @@ This API implements the abstract operation ToString as defined in
 of the ECMAScript Language Specification.
 This API can be re-entrant if getters are defined on the passed-in Object.
 
-### *napi_typeof*
+### napi_typeof
 <!-- YAML
 added: v8.0.0
 -->
@@ -2092,7 +2092,7 @@ the object as defined in [Section 12.5.5][] of the ECMAScript Language
 Specification. However, it has support for detecting an External value.
 If `value` has a type that is invalid, an error is returned.
 
-### *napi_instanceof*
+### napi_instanceof
 <!-- YAML
 added: v8.0.0
 -->
@@ -2117,7 +2117,7 @@ defined in
 [Section 12.10.4](https://tc39.github.io/ecma262/#sec-instanceofoperator)
 of the ECMAScript Language Specification.
 
-### *napi_is_array*
+### napi_is_array
 <!-- YAML
 added: v8.0.0
 -->
@@ -2135,7 +2135,7 @@ This API represents invoking the `IsArray` operation on the object
 as defined in [Section 7.2.2](https://tc39.github.io/ecma262/#sec-isarray)
 of the ECMAScript Language Specification.
 
-### *napi_is_arraybuffer*
+### napi_is_arraybuffer
 <!-- YAML
 added: v8.0.0
 -->
@@ -2151,7 +2151,7 @@ Returns `napi_ok` if the API succeeded.
 
 This API checks if the Object passsed in is an array buffer.
 
-### *napi_is_buffer*
+### napi_is_buffer
 <!-- YAML
 added: v8.0.0
 -->
@@ -2168,7 +2168,7 @@ Returns `napi_ok` if the API succeeded.
 
 This API checks if the Object passsed in is a buffer.
 
-### *napi_is_error*
+### napi_is_error
 <!-- YAML
 added: v8.0.0
 -->
@@ -2184,7 +2184,7 @@ Returns `napi_ok` if the API succeeded.
 
 This API checks if the Object passsed in is an Error.
 
-### *napi_is_typedarray*
+### napi_is_typedarray
 <!-- YAML
 added: v8.0.0
 -->
@@ -2202,7 +2202,7 @@ This API checks if the Object passsed in is a typed array.
 
 
 
-### *napi_is_dataview*
+### napi_is_dataview
 <!-- YAML
 added: REPLACEME
 -->
@@ -2219,7 +2219,7 @@ Returns `napi_ok` if the API succeeded.
 
 This API checks if the Object passed in is a DataView.
 
-### *napi_strict_equals*
+### napi_strict_equals
 <!-- YAML
 added: v8.0.0
 -->
@@ -2373,7 +2373,7 @@ if (status != napi_ok) return status;
 ```
 
 ### Structures
-#### *napi_property_attributes*
+#### napi_property_attributes
 ```C
 typedef enum {
   napi_default = 0,
@@ -2407,7 +2407,7 @@ a static property on a class as opposed to an instance property, which is the
 default. This is used only by [`napi_define_class`][]. It is ignored by
 `napi_define_properties`.
 
-#### *napi_property_descriptor*
+#### napi_property_descriptor
 ```C
 typedef struct {
   // One of utf8name or name should be NULL.
@@ -2453,7 +2453,7 @@ this function is invoked.
 See [`napi_property_attributes`](#napi_property_attributes).
 
 ### Functions
-#### *napi_get_property_names*
+#### napi_get_property_names
 <!-- YAML
 added: v8.0.0
 -->
@@ -2474,7 +2474,7 @@ Returns `napi_ok` if the API succeeded.
 
 This API returns the array of propertys for the Object passed in
 
-#### *napi_set_property*
+#### napi_set_property
 <!-- YAML
 added: v8.0.0
 -->
@@ -2494,7 +2494,7 @@ Returns `napi_ok` if the API succeeded.
 
 This API set a property on the Object passed in.
 
-#### *napi_get_property*
+#### napi_get_property
 <!-- YAML
 added: v8.0.0
 -->
@@ -2515,7 +2515,7 @@ Returns `napi_ok` if the API succeeded.
 This API gets the requested property from the Object passed in.
 
 
-#### *napi_has_property*
+#### napi_has_property
 <!-- YAML
 added: v8.0.0
 -->
@@ -2536,7 +2536,7 @@ Returns `napi_ok` if the API succeeded.
 This API checks if the Object passed in has the named property.
 
 
-#### *napi_delete_property*
+#### napi_delete_property
 <!-- YAML
 added: REPLACEME
 -->
@@ -2558,7 +2558,7 @@ Returns `napi_ok` if the API succeeded.
 This API attempts to delete the `key` own property from `object`.
 
 
-#### *napi_has_own_property*
+#### napi_has_own_property
 <!-- YAML
 added: REPLACEME
 -->
@@ -2581,7 +2581,7 @@ be a string or a Symbol, or an error will be thrown. N-API will not perform any
 conversion between data types.
 
 
-#### *napi_set_named_property*
+#### napi_set_named_property
 <!-- YAML
 added: v8.0.0
 -->
@@ -2602,7 +2602,7 @@ Returns `napi_ok` if the API succeeded.
 This method is equivalent to calling [`napi_set_property`][] with a `napi_value`
 created from the string passed in as `utf8Name`
 
-#### *napi_get_named_property*
+#### napi_get_named_property
 <!-- YAML
 added: v8.0.0
 -->
@@ -2623,7 +2623,7 @@ Returns `napi_ok` if the API succeeded.
 This method is equivalent to calling [`napi_get_property`][] with a `napi_value`
 created from the string passed in as `utf8Name`
 
-#### *napi_has_named_property*
+#### napi_has_named_property
 <!-- YAML
 added: v8.0.0
 -->
@@ -2644,7 +2644,7 @@ Returns `napi_ok` if the API succeeded.
 This method is equivalent to calling [`napi_has_property`][] with a `napi_value`
 created from the string passed in as `utf8Name`
 
-#### *napi_set_element*
+#### napi_set_element
 <!-- YAML
 added: v8.0.0
 -->
@@ -2664,7 +2664,7 @@ Returns `napi_ok` if the API succeeded.
 
 This API sets and element on the Object passed in.
 
-#### *napi_get_element*
+#### napi_get_element
 <!-- YAML
 added: v8.0.0
 -->
@@ -2684,7 +2684,7 @@ Returns `napi_ok` if the API succeeded.
 
 This API gets the element at the requested index.
 
-#### *napi_has_element*
+#### napi_has_element
 <!-- YAML
 added: v8.0.0
 -->
@@ -2705,7 +2705,7 @@ Returns `napi_ok` if the API succeeded.
 This API returns if the Object passed in has an element at the
 requested index.
 
-#### *napi_delete_element*
+#### napi_delete_element
 <!-- YAML
 added: REPLACEME
 -->
@@ -2726,7 +2726,7 @@ Returns `napi_ok` if the API succeeded.
 
 This API attempts to delete the specified `index` from `object`.
 
-#### *napi_define_properties*
+#### napi_define_properties
 <!-- YAML
 added: v8.0.0
 -->
@@ -2769,7 +2769,7 @@ like a regular JavaScript function call, or as a constructor
 function.
 
 
-### *napi_call_function*
+### napi_call_function
 <!-- YAML
 added: v8.0.0
 -->
@@ -2835,7 +2835,7 @@ status = napi_get_value_int32(env, return_val, &result);
 if (status != napi_ok) return;
 ```
 
-### *napi_create_function*
+### napi_create_function
 <!-- YAML
 added: v8.0.0
 -->
@@ -2903,7 +2903,7 @@ myaddon.sayHello();
 `NAPI_MODULE` in the earlier snippet but the name of the target in `binding.gyp`
 responsible for creating the `.node` file.
 
-### *napi_get_cb_info*
+### napi_get_cb_info
 <!-- YAML
 added: v8.0.0
 -->
@@ -2933,7 +2933,7 @@ Returns `napi_ok` if the API succeeded.
 This method is used within a callback function to retrieve details about the
 call like the arguments and the `this` pointer from a given callback info.
 
-### *napi_get_new_target*
+### napi_get_new_target
 <!-- YAML
 added: REPLACEME
 -->
@@ -2952,7 +2952,7 @@ Returns `napi_ok` if the API succeeded.
 This API returns the `new.target` of the constructor call. If the current
 callback is not a constructor call, the result is `NULL`.
 
-### *napi_new_instance*
+### napi_new_instance
 <!-- YAML
 added: v8.0.0
 -->
@@ -3047,7 +3047,7 @@ if (is_instance) {
 
 The reference must be freed once it is no longer needed.
 
-### *napi_define_class*
+### napi_define_class
 <!-- YAML
 added: v8.0.0
 -->
@@ -3103,7 +3103,7 @@ case, to prevent the function value from being garbage-collected, create a
 persistent reference to it using [`napi_create_reference`][] and ensure the
 reference count is kept >= 1.
 
-### *napi_wrap*
+### napi_wrap
 <!-- YAML
 added: v8.0.0
 -->
@@ -3165,7 +3165,7 @@ native instance associated with it by virtue of a previous call to
 another native instance with the given object, call `napi_remove_wrap()` on it
 first.
 
-### *napi_unwrap*
+### napi_unwrap
 <!-- YAML
 added: v8.0.0
 -->
@@ -3190,7 +3190,7 @@ method or accessor, then the `this` argument to the callback is the wrapper
 object; the wrapped C++ instance that is the target of the call can be obtained
 then by calling `napi_unwrap()` on the wrapper object.
 
-### *napi_remove_wrap*
+### napi_remove_wrap
 <!-- YAML
 added: REPLACEME
 -->

From 5d06fab7168f18351a90bea1027496b26208d812 Mon Sep 17 00:00:00 2001
From: Jinho Bang <zino@chromium.org>
Date: Mon, 8 Jan 2018 23:37:27 +0900
Subject: [PATCH 149/183] n-api: throw RangeError napi_create_typedarray()

According to the ECMA spec, we should throw a RangeError in the
following cases:
  - `(length * elementSize) + offset` > the size of the array passed in
  - `offset % elementSize` != `0`

In the current implementation, this check was omitted. So, the following
code will cause a crash.
  ```
  napi_create_typedarray(env, napi_uint16_array, 2 /* length */,
                         buffer, 1 /* byte_offset */, &output_array);
  ```

This change fixes the problem and write some related tests.

Refs:
https://tc39.github.io/ecma262/#sec-typedarray-buffer-byteoffset-length

PR-URL: https://github.com/nodejs/node/pull/18037
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 src/node_api.cc                               | 51 +++++++++++++++----
 test/addons-napi/test_typedarray/test.js      | 18 +++++++
 .../test_typedarray/test_typedarray.c         | 28 ++++++++--
 3 files changed, 85 insertions(+), 12 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 19b993300d1b00..93cce1909f0860 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -149,6 +149,30 @@ struct napi_env__ {
   (!try_catch.HasCaught() ? napi_ok \
                          : napi_set_last_error((env), napi_pending_exception))
 
+#define THROW_RANGE_ERROR_IF_FALSE(env, condition, error, message) \
+  do {                                                             \
+    if (!(condition)) {                                            \
+      napi_throw_range_error((env), (error), (message));           \
+      return napi_set_last_error((env), napi_generic_failure);     \
+    }                                                              \
+  } while (0)
+
+#define CREATE_TYPED_ARRAY(                                                    \
+    env, type, size_of_element, buffer, byte_offset, length, out)              \
+  do {                                                                         \
+    if ((size_of_element) > 1) {                                               \
+      THROW_RANGE_ERROR_IF_FALSE(                                              \
+          (env), (byte_offset) % (size_of_element) == 0,                       \
+          "ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT",                             \
+          "start offset of "#type" should be a multiple of "#size_of_element); \
+    }                                                                          \
+    THROW_RANGE_ERROR_IF_FALSE((env), (length) * (size_of_element) +           \
+        (byte_offset) <= buffer->ByteLength(),                                 \
+        "ERR_NAPI_INVALID_TYPEDARRAY_LENGTH",                                  \
+        "Invalid typed array length");                                         \
+    (out) = v8::type::New((buffer), (byte_offset), (length));                  \
+  } while (0)
+
 namespace v8impl {
 
 // convert from n-api property attributes to v8::PropertyAttribute
@@ -3157,31 +3181,40 @@ napi_status napi_create_typedarray(napi_env env,
 
   switch (type) {
     case napi_int8_array:
-      typedArray = v8::Int8Array::New(buffer, byte_offset, length);
+      CREATE_TYPED_ARRAY(
+          env, Int8Array, 1, buffer, byte_offset, length, typedArray);
       break;
     case napi_uint8_array:
-      typedArray = v8::Uint8Array::New(buffer, byte_offset, length);
+      CREATE_TYPED_ARRAY(
+          env, Uint8Array, 1, buffer, byte_offset, length, typedArray);
       break;
     case napi_uint8_clamped_array:
-      typedArray = v8::Uint8ClampedArray::New(buffer, byte_offset, length);
+      CREATE_TYPED_ARRAY(
+          env, Uint8ClampedArray, 1, buffer, byte_offset, length, typedArray);
       break;
     case napi_int16_array:
-      typedArray = v8::Int16Array::New(buffer, byte_offset, length);
+      CREATE_TYPED_ARRAY(
+          env, Int16Array, 2, buffer, byte_offset, length, typedArray);
       break;
     case napi_uint16_array:
-      typedArray = v8::Uint16Array::New(buffer, byte_offset, length);
+      CREATE_TYPED_ARRAY(
+          env, Uint16Array, 2, buffer, byte_offset, length, typedArray);
       break;
     case napi_int32_array:
-      typedArray = v8::Int32Array::New(buffer, byte_offset, length);
+      CREATE_TYPED_ARRAY(
+          env, Int32Array, 4, buffer, byte_offset, length, typedArray);
       break;
     case napi_uint32_array:
-      typedArray = v8::Uint32Array::New(buffer, byte_offset, length);
+      CREATE_TYPED_ARRAY(
+          env, Uint32Array, 4, buffer, byte_offset, length, typedArray);
       break;
     case napi_float32_array:
-      typedArray = v8::Float32Array::New(buffer, byte_offset, length);
+      CREATE_TYPED_ARRAY(
+          env, Float32Array, 4, buffer, byte_offset, length, typedArray);
       break;
     case napi_float64_array:
-      typedArray = v8::Float64Array::New(buffer, byte_offset, length);
+      CREATE_TYPED_ARRAY(
+          env, Float64Array, 8, buffer, byte_offset, length, typedArray);
       break;
     default:
       return napi_set_last_error(env, napi_invalid_arg);
diff --git a/test/addons-napi/test_typedarray/test.js b/test/addons-napi/test_typedarray/test.js
index 27ef054fe4635e..4a4e79ebe7bcdb 100644
--- a/test/addons-napi/test_typedarray/test.js
+++ b/test/addons-napi/test_typedarray/test.js
@@ -55,3 +55,21 @@ arrayTypes.forEach((currentType) => {
   assert.notStrictEqual(theArray, template);
   assert.strictEqual(theArray.buffer, buffer);
 });
+
+arrayTypes.forEach((currentType) => {
+  const template = Reflect.construct(currentType, buffer);
+  assert.throws(() => {
+    test_typedarray.CreateTypedArray(template, buffer, 0, 136);
+  }, /Invalid typed array length/);
+});
+
+const nonByteArrayTypes = [ Int16Array, Uint16Array, Int32Array, Uint32Array,
+                            Float32Array, Float64Array ];
+nonByteArrayTypes.forEach((currentType) => {
+  const template = Reflect.construct(currentType, buffer);
+  assert.throws(() => {
+    test_typedarray.CreateTypedArray(template, buffer,
+                                     currentType.BYTES_PER_ELEMENT + 1, 1);
+    console.log(`start of offset ${currentType}`);
+  }, /start offset of/);
+});
diff --git a/test/addons-napi/test_typedarray/test_typedarray.c b/test/addons-napi/test_typedarray/test_typedarray.c
index 93995d450c440b..febb45e715cb11 100644
--- a/test/addons-napi/test_typedarray/test_typedarray.c
+++ b/test/addons-napi/test_typedarray/test_typedarray.c
@@ -97,11 +97,11 @@ napi_value External(napi_env env, napi_callback_info info) {
 }
 
 napi_value CreateTypedArray(napi_env env, napi_callback_info info) {
-  size_t argc = 2;
-  napi_value args[2];
+  size_t argc = 4;
+  napi_value args[4];
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
-  NAPI_ASSERT(env, argc == 2, "Wrong number of arguments");
+  NAPI_ASSERT(env, argc == 2 || argc == 4, "Wrong number of arguments");
 
   napi_value input_array = args[0];
   napi_valuetype valuetype0;
@@ -136,6 +136,28 @@ napi_value CreateTypedArray(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_get_typedarray_info(
       env, input_array, &type, &length, NULL, &in_array_buffer, &byte_offset));
 
+  if (argc == 4) {
+    napi_valuetype valuetype2;
+    NAPI_CALL(env, napi_typeof(env, args[2], &valuetype2));
+
+    NAPI_ASSERT(env, valuetype2 == napi_number,
+        "Wrong type of arguments. Expects a number as third argument.");
+
+    uint32_t uint32_length;
+    NAPI_CALL(env, napi_get_value_uint32(env, args[2], &uint32_length));
+    length = uint32_length;
+
+    napi_valuetype valuetype3;
+    NAPI_CALL(env, napi_typeof(env, args[3], &valuetype3));
+
+    NAPI_ASSERT(env, valuetype3 == napi_number,
+        "Wrong type of arguments. Expects a number as third argument.");
+
+    uint32_t uint32_byte_offset;
+    NAPI_CALL(env, napi_get_value_uint32(env, args[3], &uint32_byte_offset));
+    byte_offset = uint32_byte_offset;
+  }
+
   napi_value output_array;
   NAPI_CALL(env, napi_create_typedarray(
       env, type, length, input_buffer, byte_offset, &output_array));

From e32cca2f2c9e61328f208e47b443ed3f3e6c101f Mon Sep 17 00:00:00 2001
From: furstenheim <furstenheim@gmail.com>
Date: Sun, 14 Jan 2018 19:01:51 +0100
Subject: [PATCH 150/183] test: fixed typos in napi test
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/18148
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 test/addons-napi/test_symbol/test_symbol.c         |  2 +-
 test/addons-napi/test_typedarray/test_typedarray.c | 14 +++++++-------
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/test/addons-napi/test_symbol/test_symbol.c b/test/addons-napi/test_symbol/test_symbol.c
index acb1c7f715409a..87f6cdde671600 100644
--- a/test/addons-napi/test_symbol/test_symbol.c
+++ b/test/addons-napi/test_symbol/test_symbol.c
@@ -12,7 +12,7 @@ napi_value Test(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
 
   NAPI_ASSERT(env, valuetype == napi_symbol,
-      "Wrong type of argments. Expects a symbol.");
+      "Wrong type of arguments. Expects a symbol.");
 
   char buffer[128];
   size_t buffer_size = 128;
diff --git a/test/addons-napi/test_typedarray/test_typedarray.c b/test/addons-napi/test_typedarray/test_typedarray.c
index febb45e715cb11..278812f98d5971 100644
--- a/test/addons-napi/test_typedarray/test_typedarray.c
+++ b/test/addons-napi/test_typedarray/test_typedarray.c
@@ -13,20 +13,20 @@ napi_value Multiply(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
 
   NAPI_ASSERT(env, valuetype0 == napi_object,
-      "Wrong type of argments. Expects a typed array as first argument.");
+      "Wrong type of arguments. Expects a typed array as first argument.");
 
   napi_value input_array = args[0];
   bool is_typedarray;
   NAPI_CALL(env, napi_is_typedarray(env, input_array, &is_typedarray));
 
   NAPI_ASSERT(env, is_typedarray,
-      "Wrong type of argments. Expects a typed array as first argument.");
+      "Wrong type of arguments. Expects a typed array as first argument.");
 
   napi_valuetype valuetype1;
   NAPI_CALL(env, napi_typeof(env, args[1], &valuetype1));
 
   NAPI_ASSERT(env, valuetype1 == napi_number,
-      "Wrong type of argments. Expects a number as second argument.");
+      "Wrong type of arguments. Expects a number as second argument.");
 
   double multiplier;
   NAPI_CALL(env, napi_get_value_double(env, args[1], &multiplier));
@@ -108,26 +108,26 @@ napi_value CreateTypedArray(napi_env env, napi_callback_info info) {
   NAPI_CALL(env, napi_typeof(env, input_array, &valuetype0));
 
   NAPI_ASSERT(env, valuetype0 == napi_object,
-      "Wrong type of argments. Expects a typed array as first argument.");
+      "Wrong type of arguments. Expects a typed array as first argument.");
 
   bool is_typedarray;
   NAPI_CALL(env, napi_is_typedarray(env, input_array, &is_typedarray));
 
   NAPI_ASSERT(env, is_typedarray,
-      "Wrong type of argments. Expects a typed array as first argument.");
+      "Wrong type of arguments. Expects a typed array as first argument.");
 
   napi_valuetype valuetype1;
   napi_value input_buffer = args[1];
   NAPI_CALL(env, napi_typeof(env, input_buffer, &valuetype1));
 
   NAPI_ASSERT(env, valuetype1 == napi_object,
-      "Wrong type of argments. Expects an array buffer as second argument.");
+      "Wrong type of arguments. Expects an array buffer as second argument.");
 
   bool is_arraybuffer;
   NAPI_CALL(env, napi_is_arraybuffer(env, input_buffer, &is_arraybuffer));
 
   NAPI_ASSERT(env, is_arraybuffer,
-      "Wrong type of argments. Expects an array buffer as second argument.");
+      "Wrong type of arguments. Expects an array buffer as second argument.");
 
   napi_typedarray_type type;
   napi_value in_array_buffer;

From 91c9e193dc4074a2cbfdd0203424eb23e01cee0f Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Tue, 16 Jan 2018 14:05:26 -0500
Subject: [PATCH 151/183] doc: remove uannecessary Require

This was the only instance were we said a parameter
was required.  It is assumed parameters are required unless
the doc says they are option.  Remove `Required` to make
consistent with the rest of the doc

PR-URL: https://github.com/nodejs/node/pull/18184
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
---
 doc/api/n-api.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 9fc99759101489..c82ace15ed48b7 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -3281,7 +3281,7 @@ napi_status napi_create_async_work(napi_env env,
 - `[in] env`: The environment that the API is invoked under.
 - `[in] async_resource`: An optional object associated with the async work
   that will be passed to possible async_hooks [`init` hooks][].
-- `[in] async_resource_name`: An identifier for the kind of resource that is
+- `[in] async_resource_name`: Identifier for the kind of resource that is
 being provided for diagnostic information exposed by the `async_hooks` API.
 - `[in] execute`: The native function which should be called to excute
 the logic asynchronously.
@@ -3380,7 +3380,7 @@ napi_status napi_async_init(napi_env env,
 - `[in] env`: The environment that the API is invoked under.
 - `[in] async_resource`: An optional object associated with the async work
   that will be passed to possible `async_hooks` [`init` hooks][].
-- `[in] async_resource_name`: Required identifier for the kind of resource
+- `[in] async_resource_name`: Identifier for the kind of resource
   that is being provided for diagnostic information exposed by the
   `async_hooks` API.
 - `[out] result`: The initialized async context.

From f103e2123dd418c07ed62f8412aa9b4908d0c5c8 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Tue, 23 Jan 2018 22:18:38 -0800
Subject: [PATCH 152/183] test: refactor addons-napi/test_exception/test.js

* provide block scoping to prevent unintended side effects
* remove confusing and unnecessary assertion message
* use consisitent `actual, expected` argument order for assertions

PR-URL: https://github.com/nodejs/node/pull/18340
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/addons-napi/test_exception/test.js | 86 ++++++++++++-------------
 1 file changed, 42 insertions(+), 44 deletions(-)

diff --git a/test/addons-napi/test_exception/test.js b/test/addons-napi/test_exception/test.js
index 8bd2f50b12b15f..83961411df7574 100644
--- a/test/addons-napi/test_exception/test.js
+++ b/test/addons-napi/test_exception/test.js
@@ -4,49 +4,47 @@ const common = require('../../common');
 const test_exception = require(`./build/${common.buildType}/test_exception`);
 const assert = require('assert');
 const theError = new Error('Some error');
-function throwTheError() {
-  throw theError;
+
+{
+  const throwTheError = () => { throw theError; };
+
+  // Test that the native side successfully captures the exception
+  let returnedError = test_exception.returnException(throwTheError);
+  assert.strictEqual(theError, returnedError);
+
+  // Test that the native side passes the exception through
+  assert.throws(
+    () => { test_exception.allowException(throwTheError); },
+    (err) => err === theError
+  );
+
+  // Test that the exception thrown above was marked as pending
+  // before it was handled on the JS side
+  assert.strictEqual(test_exception.wasPending(), true,
+                     'VM was marked as having an exception pending' +
+                     ' when it was allowed through');
+
+  // Test that the native side does not capture a non-existing exception
+  returnedError = test_exception.returnException(common.mustCall());
+  assert.strictEqual(returnedError, undefined,
+                     'Returned error should be undefined when no exception is' +
+                     ` thrown, but ${returnedError} was passed`);
 }
-let caughtError;
-
-// Test that the native side successfully captures the exception
-let returnedError = test_exception.returnException(throwTheError);
-assert.strictEqual(theError, returnedError);
-
-// Test that the native side passes the exception through
-assert.throws(
-  () => {
-    test_exception.allowException(throwTheError);
-  },
-  function(err) {
-    return err === theError;
-  },
-  'Thrown exception was allowed to pass through unhindered'
-);
-
-// Test that the exception thrown above was marked as pending
-// before it was handled on the JS side
-assert.strictEqual(test_exception.wasPending(), true,
-                   'VM was marked as having an exception pending' +
-                   ' when it was allowed through');
-
-// Test that the native side does not capture a non-existing exception
-returnedError = test_exception.returnException(common.mustCall());
-assert.strictEqual(undefined, returnedError,
-                   'Returned error should be undefined when no exception is' +
-                   ` thrown, but ${returnedError} was passed`);
-
-// Test that no exception appears that was not thrown by us
-try {
-  test_exception.allowException(common.mustCall());
-} catch (anError) {
-  caughtError = anError;
+
+{
+  // Test that no exception appears that was not thrown by us
+  let caughtError;
+  try {
+    test_exception.allowException(common.mustCall());
+  } catch (anError) {
+    caughtError = anError;
+  }
+  assert.strictEqual(caughtError, undefined,
+                     'No exception originated on the native side, but' +
+                     ` ${caughtError} was passed`);
+
+  // Test that the exception state remains clear when no exception is thrown
+  assert.strictEqual(test_exception.wasPending(), false,
+                     'VM was not marked as having an exception pending' +
+                     ' when none was allowed through');
 }
-assert.strictEqual(undefined, caughtError,
-                   'No exception originated on the native side, but' +
-                   ` ${caughtError} was passed`);
-
-// Test that the exception state remains clear when no exception is thrown
-assert.strictEqual(test_exception.wasPending(), false,
-                   'VM was not marked as having an exception pending' +
-                   ' when none was allowed through');

From 0fd8ceb251ab4964c9750db93f156c7d0aa16c93 Mon Sep 17 00:00:00 2001
From: Aaron Kau <aaron.kau@rutgers.edu>
Date: Sat, 27 Jan 2018 14:20:13 -0500
Subject: [PATCH 153/183] n-api: change assert ok check to notStrictEqual.

PR-URL: https://github.com/nodejs/node/pull/18414
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 test/addons-napi/test_general/test.js | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/test/addons-napi/test_general/test.js b/test/addons-napi/test_general/test.js
index 10b85ef727bb20..15461cef2f6a36 100644
--- a/test/addons-napi/test_general/test.js
+++ b/test/addons-napi/test_general/test.js
@@ -28,9 +28,9 @@ assert.strictEqual(test_general.testGetPrototype(baseObject),
                    Object.getPrototypeOf(baseObject));
 assert.strictEqual(test_general.testGetPrototype(extendedObject),
                    Object.getPrototypeOf(extendedObject));
-assert.ok(test_general.testGetPrototype(baseObject) !==
-          test_general.testGetPrototype(extendedObject),
-          'Prototypes for base and extended should be different');
+// Prototypes for base and extended should be different.
+assert.notStrictEqual(test_general.testGetPrototype(baseObject),
+                      test_general.testGetPrototype(extendedObject));
 
 // test version management funcitons
 // expected version is currently 1
@@ -70,17 +70,15 @@ assert.strictEqual(test_general.derefItemWasCalled(), true,
 // Assert that wrapping twice fails.
 const x = {};
 test_general.wrap(x);
-assert.throws(function() {
-  test_general.wrap(x);
-}, Error);
+assert.throws(() => test_general.wrap(x), Error);
 
 // Ensure that wrapping, removing the wrap, and then wrapping again works.
 const y = {};
 test_general.wrap(y);
 test_general.removeWrap(y);
-assert.doesNotThrow(function() {
-  test_general.wrap(y);
-}, Error, 'Wrapping twice succeeds if a remove_wrap() separates the instances');
+assert.doesNotThrow(() => test_general.wrap(y), Error,
+                    'Wrapping twice succeeds if a remove_wrap()' +
+                    ' separates the instances');
 
 // Ensure that removing a wrap and garbage collecting does not fire the
 // finalize callback.

From e57f34c310e937b8f3ffd11f9a0f145e9934f72d Mon Sep 17 00:00:00 2001
From: Ben Wilcox <reccanti@gmail.com>
Date: Sat, 27 Jan 2018 14:39:55 -0500
Subject: [PATCH 154/183] test: show pending exception error in napi tests

Shows the result of the wasPending in the error message if the
assertion fails.

PR-URL: https://github.com/nodejs/node/pull/18413
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 test/addons-napi/test_exception/test.js | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/test/addons-napi/test_exception/test.js b/test/addons-napi/test_exception/test.js
index 83961411df7574..787b7d78b1c72b 100644
--- a/test/addons-napi/test_exception/test.js
+++ b/test/addons-napi/test_exception/test.js
@@ -20,9 +20,10 @@ const theError = new Error('Some error');
 
   // Test that the exception thrown above was marked as pending
   // before it was handled on the JS side
-  assert.strictEqual(test_exception.wasPending(), true,
-                     'VM was marked as having an exception pending' +
-                     ' when it was allowed through');
+  const exception_pending = test_exception.wasPending();
+  assert.strictEqual(exception_pending, true,
+                     'Exception not pending as expected,' +
+                     ` .wasPending() returned ${exception_pending}`);
 
   // Test that the native side does not capture a non-existing exception
   returnedError = test_exception.returnException(common.mustCall());
@@ -44,7 +45,8 @@ const theError = new Error('Some error');
                      ` ${caughtError} was passed`);
 
   // Test that the exception state remains clear when no exception is thrown
-  assert.strictEqual(test_exception.wasPending(), false,
-                     'VM was not marked as having an exception pending' +
-                     ' when none was allowed through');
+  const exception_pending = test_exception.wasPending();
+  assert.strictEqual(exception_pending, false,
+                     'Exception state did not remain clear as expected,' +
+                     ` .wasPending() returned ${exception_pending}`);
 }

From 5c183d76dd32ab8062cd792ebe5e0f7cd35779f9 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Mon, 22 Jan 2018 23:13:02 -0500
Subject: [PATCH 155/183] n-api: implement wrapping using private properties

PR-URL: https://github.com/nodejs/node/pull/18311
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Fixes: https://github.com/nodejs/node/issues/14367
---
 src/env.h               |   2 +
 src/node_api.cc         | 160 ++++++++++++----------------------------
 src/node_api_backport.h |   1 +
 3 files changed, 52 insertions(+), 111 deletions(-)

diff --git a/src/env.h b/src/env.h
index 36ca7004ad748c..0045a4fa79c95e 100644
--- a/src/env.h
+++ b/src/env.h
@@ -62,6 +62,8 @@ namespace node {
   V(npn_buffer_private_symbol, "node:npnBuffer")                              \
   V(processed_private_symbol, "node:processed")                               \
   V(selected_npn_buffer_private_symbol, "node:selectedNpnBuffer")             \
+  V(napi_env, "node:napi:env")                                                \
+  V(napi_wrapper, "node:napi:wrapper")                                        \
 
 // Strings are per-isolate primitives but Environment proxies them
 // for the sake of convenience.  Strings should be ASCII-only.
diff --git a/src/node_api.cc b/src/node_api.cc
index 93cce1909f0860..dc32986e3adfc3 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -20,7 +20,6 @@
 #include "node_internals.h"
 #include "env-inl.h"
 #include "node_api_backport.h"
-#include "util.h"
 
 static
 napi_status napi_set_last_error(napi_env env, napi_status error_code,
@@ -53,6 +52,9 @@ struct napi_env__ {
   uv_loop_t* loop = nullptr;
 };
 
+#define NAPI_PRIVATE_KEY(context, suffix) \
+  (node::Environment::GetCurrent((context))->napi_ ## suffix())
+
 #define ENV_OBJECT_TEMPLATE(env, prefix, destination, field_count) \
   do {                                                             \
     if ((env)->prefix ## _template.IsEmpty()) {                    \
@@ -383,6 +385,10 @@ class Reference : private Finalizer {
   }
 
  public:
+  void* Data() {
+    return _finalize_data;
+  }
+
   static Reference* New(napi_env env,
                         v8::Local<v8::Value> value,
                         uint32_t initial_refcount,
@@ -742,45 +748,6 @@ v8::Local<v8::Object> CreateAccessorCallbackData(napi_env env,
   return cbdata;
 }
 
-int kWrapperFields = 3;
-
-// Pointer used to identify items wrapped by N-API. Used by FindWrapper and
-// napi_wrap().
-const char napi_wrap_name[] = "N-API Wrapper";
-
-// Search the object's prototype chain for the wrapper object. Usually the
-// wrapper would be the first in the chain, but it is OK for other objects to
-// be inserted in the prototype chain.
-static
-bool FindWrapper(v8::Local<v8::Object> obj,
-                 v8::Local<v8::Object>* result = nullptr,
-                 v8::Local<v8::Object>* parent = nullptr) {
-  v8::Local<v8::Object> wrapper = obj;
-
-  do {
-    v8::Local<v8::Value> proto = wrapper->GetPrototype();
-    if (proto.IsEmpty() || !proto->IsObject()) {
-      return false;
-    }
-    if (parent != nullptr) {
-      *parent = wrapper;
-    }
-    wrapper = proto.As<v8::Object>();
-    if (wrapper->InternalFieldCount() == kWrapperFields) {
-      v8::Local<v8::Value> external = wrapper->GetInternalField(1);
-      if (external->IsExternal() &&
-          external.As<v8::External>()->Value() == v8impl::napi_wrap_name) {
-        break;
-      }
-    }
-  } while (true);
-
-  if (result != nullptr) {
-    *result = wrapper;
-  }
-  return true;
-}
-
 static void DeleteEnv(napi_env env, void* data, void* hint) {
   delete env;
 }
@@ -797,11 +764,8 @@ napi_env GetEnv(v8::Local<v8::Context> context) {
   // because we need to stop hard if either of them is empty.
   //
   // Re https://github.com/nodejs/node/pull/14217#discussion_r128775149
-  auto key = v8::Private::ForApi(isolate,
-      v8::String::NewFromOneByte(isolate,
-          reinterpret_cast<const uint8_t*>("N-API Environment"),
-          v8::NewStringType::kInternalized).ToLocalChecked());
-  auto value = global->GetPrivate(context, key).ToLocalChecked();
+  auto value = global->GetPrivate(context, NAPI_PRIVATE_KEY(context, env))
+      .ToLocalChecked();
 
   if (value->IsExternal()) {
     result = static_cast<napi_env>(value.As<v8::External>()->Value());
@@ -811,7 +775,8 @@ napi_env GetEnv(v8::Local<v8::Context> context) {
 
     // We must also stop hard if the result of assigning the env to the global
     // is either nothing or false.
-    CHECK(global->SetPrivate(context, key, external).FromJust());
+    CHECK(global->SetPrivate(context, NAPI_PRIVATE_KEY(context, env), external)
+        .FromJust());
 
     // Create a self-destructing reference to external that will get rid of the
     // napi_env when external goes out of scope.
@@ -821,28 +786,46 @@ napi_env GetEnv(v8::Local<v8::Context> context) {
   return result;
 }
 
+enum UnwrapAction {
+  KeepWrap,
+  RemoveWrap
+};
+
 static
 napi_status Unwrap(napi_env env,
                    napi_value js_object,
                    void** result,
-                   v8::Local<v8::Object>* wrapper,
-                   v8::Local<v8::Object>* parent = nullptr) {
+                   UnwrapAction action) {
+  NAPI_PREAMBLE(env);
   CHECK_ARG(env, js_object);
-  CHECK_ARG(env, result);
+  if (action == KeepWrap) {
+    CHECK_ARG(env, result);
+  }
+
+  v8::Isolate* isolate = env->isolate;
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
 
   v8::Local<v8::Value> value = v8impl::V8LocalValueFromJsValue(js_object);
   RETURN_STATUS_IF_FALSE(env, value->IsObject(), napi_invalid_arg);
   v8::Local<v8::Object> obj = value.As<v8::Object>();
 
-  RETURN_STATUS_IF_FALSE(
-    env, v8impl::FindWrapper(obj, wrapper, parent), napi_invalid_arg);
+  auto val = obj->GetPrivate(context, NAPI_PRIVATE_KEY(context, wrapper))
+      .ToLocalChecked();
+  RETURN_STATUS_IF_FALSE(env, val->IsExternal(), napi_invalid_arg);
+  Reference* reference =
+      static_cast<v8impl::Reference*>(val.As<v8::External>()->Value());
 
-  v8::Local<v8::Value> unwrappedValue = (*wrapper)->GetInternalField(0);
-  RETURN_STATUS_IF_FALSE(env, unwrappedValue->IsExternal(), napi_invalid_arg);
+  if (result) {
+    *result = reference->Data();
+  }
 
-  *result = unwrappedValue.As<v8::External>()->Value();
+  if (action == RemoveWrap) {
+    CHECK(obj->DeletePrivate(context, NAPI_PRIVATE_KEY(context, wrapper))
+        .FromJust());
+    Reference::Delete(reference);
+  }
 
-  return napi_ok;
+  return GET_RETURN_STATUS(env);
 }
 
 static
@@ -2399,26 +2382,9 @@ napi_status napi_wrap(napi_env env,
   v8::Local<v8::Object> obj = value.As<v8::Object>();
 
   // If we've already wrapped this object, we error out.
-  RETURN_STATUS_IF_FALSE(env, !v8impl::FindWrapper(obj), napi_invalid_arg);
-
-  // Create a wrapper object with an internal field to hold the wrapped pointer
-  // and a second internal field to identify the owner as N-API.
-  v8::Local<v8::ObjectTemplate> wrapper_template;
-  ENV_OBJECT_TEMPLATE(env, wrap, wrapper_template, v8impl::kWrapperFields);
-
-  auto maybe_object = wrapper_template->NewInstance(context);
-  CHECK_MAYBE_EMPTY(env, maybe_object, napi_generic_failure);
-  v8::Local<v8::Object> wrapper = maybe_object.ToLocalChecked();
-
-  // Store the pointer as an external in the wrapper.
-  wrapper->SetInternalField(0, v8::External::New(isolate, native_object));
-  wrapper->SetInternalField(1, v8::External::New(isolate,
-    reinterpret_cast<void*>(const_cast<char*>(v8impl::napi_wrap_name))));
-
-  // Insert the wrapper into the object's prototype chain.
-  v8::Local<v8::Value> proto = obj->GetPrototype();
-  CHECK(wrapper->SetPrototype(context, proto).FromJust());
-  CHECK(obj->SetPrototype(context, wrapper).FromJust());
+  RETURN_STATUS_IF_FALSE(env,
+      !obj->HasPrivate(context, NAPI_PRIVATE_KEY(context, wrapper)).FromJust(),
+      napi_invalid_arg);
 
   v8impl::Reference* reference = nullptr;
   if (result != nullptr) {
@@ -2430,52 +2396,24 @@ napi_status napi_wrap(napi_env env,
     reference = v8impl::Reference::New(
         env, obj, 0, false, finalize_cb, native_object, finalize_hint);
     *result = reinterpret_cast<napi_ref>(reference);
-  } else if (finalize_cb != nullptr) {
-    // Create a self-deleting reference just for the finalize callback.
-    reference = v8impl::Reference::New(
-        env, obj, 0, true, finalize_cb, native_object, finalize_hint);
+  } else {
+    // Create a self-deleting reference.
+    reference = v8impl::Reference::New(env, obj, 0, true, finalize_cb,
+        native_object, finalize_cb == nullptr ? nullptr : finalize_hint);
   }
 
-  if (reference != nullptr) {
-    wrapper->SetInternalField(2, v8::External::New(isolate, reference));
-  }
+  CHECK(obj->SetPrivate(context, NAPI_PRIVATE_KEY(context, wrapper),
+        v8::External::New(isolate, reference)).FromJust());
 
   return GET_RETURN_STATUS(env);
 }
 
 napi_status napi_unwrap(napi_env env, napi_value obj, void** result) {
-  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
-  // JS exceptions.
-  CHECK_ENV(env);
-  v8::Local<v8::Object> wrapper;
-  return napi_set_last_error(env, v8impl::Unwrap(env, obj, result, &wrapper));
+  return v8impl::Unwrap(env, obj, result, v8impl::KeepWrap);
 }
 
 napi_status napi_remove_wrap(napi_env env, napi_value obj, void** result) {
-  NAPI_PREAMBLE(env);
-  v8::Local<v8::Object> wrapper;
-  v8::Local<v8::Object> parent;
-  napi_status status = v8impl::Unwrap(env, obj, result, &wrapper, &parent);
-  if (status != napi_ok) {
-    return napi_set_last_error(env, status);
-  }
-
-  v8::Local<v8::Value> external = wrapper->GetInternalField(2);
-  if (external->IsExternal()) {
-    v8impl::Reference::Delete(
-        static_cast<v8impl::Reference*>(external.As<v8::External>()->Value()));
-  }
-
-  if (!parent.IsEmpty()) {
-    v8::Maybe<bool> maybe = parent->SetPrototype(
-        env->isolate->GetCurrentContext(), wrapper->GetPrototype());
-    CHECK_MAYBE_NOTHING(env, maybe, napi_generic_failure);
-    if (!maybe.FromMaybe(false)) {
-      return napi_set_last_error(env, napi_generic_failure);
-    }
-  }
-
-  return GET_RETURN_STATUS(env);
+  return v8impl::Unwrap(env, obj, result, v8impl::RemoveWrap);
 }
 
 napi_status napi_create_external(napi_env env,
diff --git a/src/node_api_backport.h b/src/node_api_backport.h
index 968169ef3bd05f..1333b33eddfe14 100644
--- a/src/node_api_backport.h
+++ b/src/node_api_backport.h
@@ -6,6 +6,7 @@
 // N-API.
 
 #include "node_internals.h"
+#include "env-inl.h"
 
 namespace node {
 

From 76dfefa56cbfa15fc371ac0accae0068249c1620 Mon Sep 17 00:00:00 2001
From: Ben Noordhuis <info@bnoordhuis.nl>
Date: Fri, 2 Feb 2018 17:27:01 +0100
Subject: [PATCH 156/183] n-api: wrap control flow macro in do/while

Make CHECK_ENV() safe to use in the following context:

    if (condition)
      CHECK_ENV(env);
    else
      something_else();

PR-URL: https://github.com/nodejs/node/pull/18532
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Ali Ijaz Sheikh <ofrobots@google.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
---
 src/node_api.cc | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index dc32986e3adfc3..58803b30bcc96b 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -75,10 +75,12 @@ struct napi_env__ {
     }                                                                   \
   } while (0)
 
-#define CHECK_ENV(env)        \
-  if ((env) == nullptr) {     \
-    return napi_invalid_arg;  \
-  }
+#define CHECK_ENV(env)          \
+  do {                          \
+    if ((env) == nullptr) {     \
+      return napi_invalid_arg;  \
+    }                           \
+  } while (0)
 
 #define CHECK_ARG(env, arg) \
   RETURN_STATUS_IF_FALSE((env), ((arg) != nullptr), napi_invalid_arg)

From b7093fad5790ff875eb227fb524e46d0e289a306 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Fri, 2 Feb 2018 10:33:01 -0500
Subject: [PATCH 157/183] doc: remove usage of you in n-api doc

We avoid using 'you' in the documentation based on our
guidelines. Remove usage in the n-api doc.

PR-URL: https://github.com/nodejs/node/pull/18528
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
---
 doc/api/n-api.md | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index c82ace15ed48b7..6084fab87a6709 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -3159,11 +3159,8 @@ required in order to enable correct proper of the reference.
 Afterward, additional manipulation of the wrapper's prototype chain may cause
 `napi_unwrap()` to fail.
 
-*Note*: Calling `napi_wrap()` a second time on an object that already has a
-native instance associated with it by virtue of a previous call to
-`napi_wrap()` will cause an error to be returned. If you wish to associate
-another native instance with the given object, call `napi_remove_wrap()` on it
-first.
+Calling napi_wrap() a second time on an object will return an error. To associate
+another native instance with the object, use napi_remove_wrap() first.
 
 ### napi_unwrap
 <!-- YAML

From ed7e64b7b2bfdb9fce42b11a047210e8a686b51f Mon Sep 17 00:00:00 2001
From: iskore <iSkore@users.noreply.github.com>
Date: Sat, 3 Feb 2018 21:57:02 -0500
Subject: [PATCH 158/183] doc: small typo in n-api.md

PR-URL: https://github.com/nodejs/node/pull/18555
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Evan Lucas <evanlucas@me.com>
---
 doc/api/n-api.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 6084fab87a6709..63f81248364afb 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -916,7 +916,7 @@ For example, to set a function to be returned by the `require()` for the addon:
 napi_value Init(napi_env env, napi_value exports) {
   napi_value method;
   napi_status status;
-  status = napi_create_function(env, "exports", Method, NULL, &method));
+  status = napi_create_function(env, "exports", Method, NULL, &method);
   if (status != napi_ok) return NULL;
   return method;
 }

From 63d1f0206337054d6b582cf2af53a69c12e868ec Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Tue, 12 Dec 2017 19:37:40 -0500
Subject: [PATCH 159/183] n-api: add methods to open/close callback scope

Add support for the following methods;
  napi_open_callback_scope
  napi_close_callback_scope

These are needed when running asynchronous methods directly
using uv.

PR-URL: https://github.com/nodejs/node/pull/18089
Fixes: https://github.com/nodejs/node/issues/15604
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
---
 doc/api/n-api.md                              |  38 +++++
 src/env-inl.h                                 |   2 +-
 src/env.h                                     |   2 +-
 src/node_api.cc                               |  62 +++++++-
 src/node_api.h                                |   8 +
 src/node_api_types.h                          |   4 +-
 .../test_callback_scope/binding.cc            | 138 ++++++++++++++++++
 .../test_callback_scope/binding.gyp           |   9 ++
 .../test_callback_scope/test-resolve-async.js |  13 ++
 test/addons-napi/test_callback_scope/test.js  |  17 +++
 10 files changed, 287 insertions(+), 6 deletions(-)
 create mode 100644 test/addons-napi/test_callback_scope/binding.cc
 create mode 100644 test/addons-napi/test_callback_scope/binding.gyp
 create mode 100644 test/addons-napi/test_callback_scope/test-resolve-async.js
 create mode 100644 test/addons-napi/test_callback_scope/test.js

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 63f81248364afb..388fa0f95d0086 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -3444,6 +3444,42 @@ is sufficient and appropriate. Use of the `napi_make_callback` function
 may be required when implementing custom async behavior that does not use
 `napi_create_async_work`.
 
+### *napi_open_callback_scope*
+<!-- YAML
+added: REPLACEME
+-->
+```C
+NAPI_EXTERN napi_status napi_open_callback_scope(napi_env env,
+                                                 napi_value resource_object,
+                                                 napi_async_context context,
+                                                 napi_callback_scope* result)
+```
+- `[in] env`: The environment that the API is invoked under.
+- `[in] resource_object`: An optional object associated with the async work
+  that will be passed to possible async_hooks [`init` hooks][].
+- `[in] context`: Context for the async operation that is
+invoking the callback. This should be a value previously obtained
+from [`napi_async_init`][].
+- `[out] result`: The newly created scope.
+
+There are cases(for example resolving promises) where it is
+necessary to have the equivalent of the scope associated with a callback
+in place when making certain N-API calls.  If there is no other script on
+the stack the [`napi_open_callback_scope`][] and
+[`napi_close_callback_scope`][] functions can be used to open/close
+the required scope.
+
+### *napi_close_callback_scope*
+<!-- YAML
+added: REPLACEME
+-->
+```C
+NAPI_EXTERN napi_status napi_close_callback_scope(napi_env env,
+                                                  napi_callback_scope scope)
+```
+- `[in] env`: The environment that the API is invoked under.
+- `[in] scope`: The scope to be closed.
+
 ## Version Management
 
 ### napi_get_node_version
@@ -3723,6 +3759,7 @@ NAPI_EXTERN napi_status napi_get_uv_event_loop(napi_env env,
 [`napi_async_init`]: #n_api_napi_async_init
 [`napi_cancel_async_work`]: #n_api_napi_cancel_async_work
 [`napi_close_escapable_handle_scope`]: #n_api_napi_close_escapable_handle_scope
+[`napi_close_callback_scope`]: #n_api_napi_close_callback_scope
 [`napi_close_handle_scope`]: #n_api_napi_close_handle_scope
 [`napi_create_async_work`]: #n_api_napi_create_async_work
 [`napi_create_error`]: #n_api_napi_create_error
@@ -3749,6 +3786,7 @@ NAPI_EXTERN napi_status napi_get_uv_event_loop(napi_env env,
 [`napi_get_last_error_info`]: #n_api_napi_get_last_error_info
 [`napi_get_and_clear_last_exception`]: #n_api_napi_get_and_clear_last_exception
 [`napi_make_callback`]: #n_api_napi_make_callback
+[`napi_open_callback_scope`]: #n_api_napi_open_callback_scope
 [`napi_open_escapable_handle_scope`]: #n_api_napi_open_escapable_handle_scope
 [`napi_open_handle_scope`]: #n_api_napi_open_handle_scope
 [`napi_property_descriptor`]: #n_api_napi_property_descriptor
diff --git a/src/env-inl.h b/src/env-inl.h
index 45a327de16931d..9b4000d75b180d 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -111,7 +111,7 @@ inline Environment::AsyncCallbackScope::~AsyncCallbackScope() {
   env_->makecallback_cntr_--;
 }
 
-inline bool Environment::AsyncCallbackScope::in_makecallback() {
+inline bool Environment::AsyncCallbackScope::in_makecallback() const {
   return env_->makecallback_cntr_ > 1;
 }
 
diff --git a/src/env.h b/src/env.h
index 0045a4fa79c95e..593f38964c7839 100644
--- a/src/env.h
+++ b/src/env.h
@@ -297,7 +297,7 @@ class Environment {
     explicit AsyncCallbackScope(Environment* env);
     ~AsyncCallbackScope();
 
-    inline bool in_makecallback();
+    inline bool in_makecallback() const;
 
    private:
     Environment* env_;
diff --git a/src/node_api.cc b/src/node_api.cc
index 58803b30bcc96b..a5902db0454eba 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -49,6 +49,7 @@ struct napi_env__ {
   bool has_instance_available;
   napi_extended_error_info last_error;
   int open_handle_scopes = 0;
+  int open_callback_scopes = 0;
   uv_loop_t* loop = nullptr;
 };
 
@@ -261,6 +262,18 @@ V8EscapableHandleScopeFromJsEscapableHandleScope(
   return reinterpret_cast<EscapableHandleScopeWrapper*>(s);
 }
 
+static
+napi_callback_scope JsCallbackScopeFromV8CallbackScope(
+    node::CallbackScope* s) {
+  return reinterpret_cast<napi_callback_scope>(s);
+}
+
+static
+node::CallbackScope* V8CallbackScopeFromJsCallbackScope(
+    napi_callback_scope s) {
+  return reinterpret_cast<node::CallbackScope*>(s);
+}
+
 //=== Conversion between V8 Handles and napi_value ========================
 
 // This asserts v8::Local<> will always be implemented with a single
@@ -552,6 +565,7 @@ class CallbackWrapperBase : public CallbackWrapper {
     napi_clear_last_error(env);
 
     int open_handle_scopes = env->open_handle_scopes;
+    int open_callback_scopes = env->open_callback_scopes;
 
     napi_value result = cb(env, cbinfo_wrapper);
 
@@ -560,6 +574,7 @@ class CallbackWrapperBase : public CallbackWrapper {
     }
 
     CHECK_EQ(env->open_handle_scopes, open_handle_scopes);
+    CHECK_EQ(env->open_callback_scopes, open_callback_scopes);
 
     if (!env->last_exception.IsEmpty()) {
       isolate->ThrowException(
@@ -917,7 +932,8 @@ const char* error_messages[] = {nullptr,
                                 "An exception is pending",
                                 "The async work item was cancelled",
                                 "napi_escape_handle already called on scope",
-                                "Invalid handle scope usage"};
+                                "Invalid handle scope usage",
+                                "Invalid callback scope usage"};
 
 static inline napi_status napi_clear_last_error(napi_env env) {
   env->last_error.error_code = napi_ok;
@@ -948,9 +964,9 @@ napi_status napi_get_last_error_info(napi_env env,
   // We don't have a napi_status_last as this would result in an ABI
   // change each time a message was added.
   static_assert(
-      node::arraysize(error_messages) == napi_handle_scope_mismatch + 1,
+      node::arraysize(error_messages) == napi_callback_scope_mismatch + 1,
       "Count of error messages must match count of error values");
-  CHECK_LE(env->last_error.error_code, napi_handle_scope_mismatch);
+  CHECK_LE(env->last_error.error_code, napi_callback_scope_mismatch);
 
   // Wait until someone requests the last error information to fetch the error
   // message string
@@ -2639,6 +2655,46 @@ napi_status napi_escape_handle(napi_env env,
   return napi_set_last_error(env, napi_escape_called_twice);
 }
 
+napi_status napi_open_callback_scope(napi_env env,
+                                     napi_value resource_object,
+                                     napi_async_context async_context_handle,
+                                     napi_callback_scope* result) {
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ENV(env);
+  CHECK_ARG(env, result);
+
+  v8::Local<v8::Context> context = env->isolate->GetCurrentContext();
+
+  node::async_context* node_async_context =
+      reinterpret_cast<node::async_context*>(async_context_handle);
+
+  v8::Local<v8::Object> resource;
+  CHECK_TO_OBJECT(env, context, resource, resource_object);
+
+  *result = v8impl::JsCallbackScopeFromV8CallbackScope(
+      new node::CallbackScope(env->isolate,
+                              resource,
+                              *node_async_context));
+
+  env->open_callback_scopes++;
+  return napi_clear_last_error(env);
+}
+
+napi_status napi_close_callback_scope(napi_env env, napi_callback_scope scope) {
+  // Omit NAPI_PREAMBLE and GET_RETURN_STATUS because V8 calls here cannot throw
+  // JS exceptions.
+  CHECK_ENV(env);
+  CHECK_ARG(env, scope);
+  if (env->open_callback_scopes == 0) {
+    return napi_callback_scope_mismatch;
+  }
+
+  env->open_callback_scopes--;
+  delete v8impl::V8CallbackScopeFromJsCallbackScope(scope);
+  return napi_clear_last_error(env);
+}
+
 napi_status napi_new_instance(napi_env env,
                               napi_value constructor,
                               size_t argc,
diff --git a/src/node_api.h b/src/node_api.h
index 8e5eef8a47728f..3b741c27b976ae 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -424,6 +424,14 @@ NAPI_EXTERN napi_status napi_escape_handle(napi_env env,
                                            napi_value escapee,
                                            napi_value* result);
 
+NAPI_EXTERN napi_status napi_open_callback_scope(napi_env env,
+                                                 napi_value resource_object,
+                                                 napi_async_context context,
+                                                 napi_callback_scope* result);
+
+NAPI_EXTERN napi_status napi_close_callback_scope(napi_env env,
+                                                  napi_callback_scope scope);
+
 // Methods to support error handling
 NAPI_EXTERN napi_status napi_throw(napi_env env, napi_value error);
 NAPI_EXTERN napi_status napi_throw_error(napi_env env,
diff --git a/src/node_api_types.h b/src/node_api_types.h
index 230c1f4ae3446f..76f38802e83e2e 100644
--- a/src/node_api_types.h
+++ b/src/node_api_types.h
@@ -15,6 +15,7 @@ typedef struct napi_value__ *napi_value;
 typedef struct napi_ref__ *napi_ref;
 typedef struct napi_handle_scope__ *napi_handle_scope;
 typedef struct napi_escapable_handle_scope__ *napi_escapable_handle_scope;
+typedef struct napi_callback_scope__ *napi_callback_scope;
 typedef struct napi_callback_info__ *napi_callback_info;
 typedef struct napi_async_context__ *napi_async_context;
 typedef struct napi_async_work__ *napi_async_work;
@@ -70,7 +71,8 @@ typedef enum {
   napi_pending_exception,
   napi_cancelled,
   napi_escape_called_twice,
-  napi_handle_scope_mismatch
+  napi_handle_scope_mismatch,
+  napi_callback_scope_mismatch
 } napi_status;
 
 typedef napi_value (*napi_callback)(napi_env env,
diff --git a/test/addons-napi/test_callback_scope/binding.cc b/test/addons-napi/test_callback_scope/binding.cc
new file mode 100644
index 00000000000000..e6631b6ac7bb52
--- /dev/null
+++ b/test/addons-napi/test_callback_scope/binding.cc
@@ -0,0 +1,138 @@
+#include "node_api.h"
+#include "uv.h"
+#include "../common.h"
+
+namespace {
+
+// the test needs to fake out the async structure, so we need to use
+// the raw structure here and then cast as done behind the scenes
+// in napi calls.
+struct async_context {
+  double async_id;
+  double trigger_async_id;
+};
+
+
+napi_value RunInCallbackScope(napi_env env, napi_callback_info info) {
+  size_t argc;
+  napi_value args[4];
+
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, nullptr, nullptr, nullptr));
+  NAPI_ASSERT(env, argc == 4 , "Wrong number of arguments");
+
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
+
+  napi_valuetype valuetype;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype));
+  NAPI_ASSERT(env, valuetype == napi_object,
+      "Wrong type of arguments. Expects an object as first argument.");
+
+  NAPI_CALL(env, napi_typeof(env, args[1], &valuetype));
+  NAPI_ASSERT(env, valuetype == napi_number,
+      "Wrong type of arguments. Expects a number as second argument.");
+
+  NAPI_CALL(env, napi_typeof(env, args[2], &valuetype));
+  NAPI_ASSERT(env, valuetype == napi_number,
+      "Wrong type of arguments. Expects a number as third argument.");
+
+  NAPI_CALL(env, napi_typeof(env, args[3], &valuetype));
+  NAPI_ASSERT(env, valuetype == napi_function,
+      "Wrong type of arguments. Expects a function as third argument.");
+
+  struct async_context context;
+  NAPI_CALL(env, napi_get_value_double(env, args[1], &context.async_id));
+  NAPI_CALL(env,
+      napi_get_value_double(env, args[2], &context.trigger_async_id));
+
+  napi_callback_scope scope = nullptr;
+  NAPI_CALL(
+      env,
+      napi_open_callback_scope(env,
+                               args[0],
+                               reinterpret_cast<napi_async_context>(&context),
+                               &scope));
+
+  // if the function has an exception pending after the call that is ok
+  // so we don't use NAPI_CALL as we must close the callback scope regardless
+  napi_value result = nullptr;
+  napi_status function_call_result =
+      napi_call_function(env, args[0], args[3], 0, nullptr, &result);
+  if (function_call_result != napi_ok) {
+    GET_AND_THROW_LAST_ERROR((env));
+  }
+
+  NAPI_CALL(env, napi_close_callback_scope(env, scope));
+
+  return result;
+}
+
+static napi_env shared_env = nullptr;
+static napi_deferred deferred = nullptr;
+
+static void Callback(uv_work_t* req, int ignored) {
+  napi_env env = shared_env;
+
+  napi_handle_scope handle_scope = nullptr;
+  NAPI_CALL_RETURN_VOID(env, napi_open_handle_scope(env, &handle_scope));
+
+  napi_value resource_name;
+  NAPI_CALL_RETURN_VOID(env, napi_create_string_utf8(
+      env, "test", NAPI_AUTO_LENGTH, &resource_name));
+  napi_async_context context;
+  NAPI_CALL_RETURN_VOID(env,
+                        napi_async_init(env, nullptr, resource_name, &context));
+
+  napi_value resource_object;
+  NAPI_CALL_RETURN_VOID(env, napi_create_object(env, &resource_object));
+
+  napi_value undefined_value;
+  NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &undefined_value));
+
+  napi_callback_scope scope = nullptr;
+  NAPI_CALL_RETURN_VOID(env, napi_open_callback_scope(env,
+                                                      resource_object,
+                                                      context,
+                                                      &scope));
+
+  NAPI_CALL_RETURN_VOID(env,
+                        napi_resolve_deferred(env, deferred, undefined_value));
+
+  NAPI_CALL_RETURN_VOID(env, napi_close_callback_scope(env, scope));
+
+  NAPI_CALL_RETURN_VOID(env, napi_close_handle_scope(env, handle_scope));
+  delete req;
+}
+
+napi_value TestResolveAsync(napi_env env, napi_callback_info info) {
+  napi_value promise = nullptr;
+  if (deferred == nullptr) {
+    shared_env = env;
+    NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
+
+    uv_loop_t* loop = nullptr;
+    NAPI_CALL(env, napi_get_uv_event_loop(env, &loop));
+
+    uv_work_t* req = new uv_work_t();
+    uv_queue_work(loop,
+                  req,
+                  [](uv_work_t*) {},
+                  Callback);
+  }
+  return promise;
+}
+
+napi_value Init(napi_env env, napi_value exports) {
+  napi_property_descriptor descriptors[] = {
+    DECLARE_NAPI_PROPERTY("runInCallbackScope", RunInCallbackScope),
+    DECLARE_NAPI_PROPERTY("testResolveAsync", TestResolveAsync)
+  };
+
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
+
+  return exports;
+}
+
+}  // anonymous namespace
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
diff --git a/test/addons-napi/test_callback_scope/binding.gyp b/test/addons-napi/test_callback_scope/binding.gyp
new file mode 100644
index 00000000000000..7ede63d94a0d77
--- /dev/null
+++ b/test/addons-napi/test_callback_scope/binding.gyp
@@ -0,0 +1,9 @@
+{
+  'targets': [
+    {
+      'target_name': 'binding',
+      'defines': [ 'V8_DEPRECATION_WARNINGS=1' ],
+      'sources': [ 'binding.cc' ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_callback_scope/test-resolve-async.js b/test/addons-napi/test_callback_scope/test-resolve-async.js
new file mode 100644
index 00000000000000..e9f4b9044c0154
--- /dev/null
+++ b/test/addons-napi/test_callback_scope/test-resolve-async.js
@@ -0,0 +1,13 @@
+'use strict';
+
+const common = require('../../common');
+const assert = require('assert');
+const { testResolveAsync } = require(`./build/${common.buildType}/binding`);
+
+let called = false;
+testResolveAsync().then(common.mustCall(() => {
+  called = true;
+}));
+
+setTimeout(common.mustCall(() => { assert(called); }),
+           common.platformTimeout(20));
diff --git a/test/addons-napi/test_callback_scope/test.js b/test/addons-napi/test_callback_scope/test.js
new file mode 100644
index 00000000000000..2f2efe5f47b98a
--- /dev/null
+++ b/test/addons-napi/test_callback_scope/test.js
@@ -0,0 +1,17 @@
+'use strict';
+
+const common = require('../../common');
+const assert = require('assert');
+const { runInCallbackScope } = require(`./build/${common.buildType}/binding`);
+
+assert.strictEqual(runInCallbackScope({}, 0, 0, () => 42), 42);
+
+{
+  process.once('uncaughtException', common.mustCall((err) => {
+    assert.strictEqual(err.message, 'foo');
+  }));
+
+  runInCallbackScope({}, 0, 0, () => {
+    throw new Error('foo');
+  });
+}

From d75fbebafd82c7e22d73283f8d9722026a2c3233 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Fri, 2 Feb 2018 20:34:19 -0500
Subject: [PATCH 160/183] n-api: remove extra reference from test

PR-URL: https://github.com/nodejs/node/pull/18542
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Tiancheng "Timothy" Gu <timothygu99@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 test/addons-napi/test_constructor/test_constructor.c | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/test/addons-napi/test_constructor/test_constructor.c b/test/addons-napi/test_constructor/test_constructor.c
index 43623d8b60a2ef..bed61cc55cd5e9 100644
--- a/test/addons-napi/test_constructor/test_constructor.c
+++ b/test/addons-napi/test_constructor/test_constructor.c
@@ -3,7 +3,6 @@
 
 static double value_ = 1;
 static double static_value_ = 10;
-napi_ref constructor_;
 
 napi_value GetValue(napi_env env, napi_callback_info info) {
   size_t argc = 0;
@@ -80,8 +79,6 @@ napi_value Init(napi_env env, napi_value exports) {
   NAPI_CALL(env, napi_define_class(env, "MyObject", NAPI_AUTO_LENGTH, New,
       NULL, sizeof(properties)/sizeof(*properties), properties, &cons));
 
-  NAPI_CALL(env, napi_create_reference(env, cons, 1, &constructor_));
-
   return cons;
 }
 

From 475336904e47f4e62296a1479693dc2c046812db Mon Sep 17 00:00:00 2001
From: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Date: Tue, 6 Feb 2018 02:00:12 +0200
Subject: [PATCH 161/183] doc: fix typo in n-api.md

PR-URL: https://github.com/nodejs/node/pull/18590
Reviewed-By: Jon Moss <me@jonathanmoss.me>
Reviewed-By: Weijia Wang <starkwang@126.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Rich Trott <rtrott@gmail.com>
Reviewed-By: Daniel Bevenius <daniel.bevenius@gmail.com>
Reviewed-By: Yuta Hiroto <hello@about-hiroppy.com>
---
 doc/api/n-api.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 388fa0f95d0086..d965f3a4693884 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -3462,7 +3462,7 @@ invoking the callback. This should be a value previously obtained
 from [`napi_async_init`][].
 - `[out] result`: The newly created scope.
 
-There are cases(for example resolving promises) where it is
+There are cases (for example resolving promises) where it is
 necessary to have the equivalent of the scope associated with a callback
 in place when making certain N-API calls.  If there is no other script on
 the stack the [`napi_open_callback_scope`][] and

From c7f4a4f9a7a8f16b7728df1155015d323c8b06da Mon Sep 17 00:00:00 2001
From: Bhavani Shankar <ebhavanishankar@gmail.com>
Date: Thu, 1 Feb 2018 15:32:41 +0530
Subject: [PATCH 162/183] test: improve error message output

PR-URL: https://github.com/nodejs/node/pull/18498
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Anatoli Papirovski <apapirovski@mac.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 test/addons-napi/test_general/test.js | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/test/addons-napi/test_general/test.js b/test/addons-napi/test_general/test.js
index 15461cef2f6a36..d43a1c69ba0c43 100644
--- a/test/addons-napi/test_general/test.js
+++ b/test/addons-napi/test_general/test.js
@@ -63,22 +63,25 @@ let w = {};
 test_general.wrap(w);
 w = null;
 global.gc();
-assert.strictEqual(test_general.derefItemWasCalled(), true,
+const derefItemWasCalled = test_general.derefItemWasCalled();
+assert.strictEqual(derefItemWasCalled, true,
                    'deref_item() was called upon garbage collecting a ' +
-                   'wrapped object');
+                   'wrapped object. test_general.derefItemWasCalled() ' +
+                   `returned ${derefItemWasCalled}`);
+
 
 // Assert that wrapping twice fails.
 const x = {};
 test_general.wrap(x);
-assert.throws(() => test_general.wrap(x), Error);
+common.expectsError(() => test_general.wrap(x),
+                    { type: Error, message: 'Invalid argument' });
 
 // Ensure that wrapping, removing the wrap, and then wrapping again works.
 const y = {};
 test_general.wrap(y);
 test_general.removeWrap(y);
-assert.doesNotThrow(() => test_general.wrap(y), Error,
-                    'Wrapping twice succeeds if a remove_wrap()' +
-                    ' separates the instances');
+// Wrapping twice succeeds if a remove_wrap() separates the instances
+assert.doesNotThrow(() => test_general.wrap(y));
 
 // Ensure that removing a wrap and garbage collecting does not fire the
 // finalize callback.
@@ -87,8 +90,11 @@ test_general.testFinalizeWrap(z);
 test_general.removeWrap(z);
 z = null;
 global.gc();
-assert.strictEqual(test_general.finalizeWasCalled(), false,
-                   'finalize callback was not called upon garbage collection');
+const finalizeWasCalled = test_general.finalizeWasCalled();
+assert.strictEqual(finalizeWasCalled, false,
+                   'finalize callback was not called upon garbage collection.' +
+                   ' test_general.finalizeWasCalled() ' +
+                   `returned ${finalizeWasCalled}`);
 
 // test napi_adjust_external_memory
 const adjustedValue = test_general.testAdjustExternalMemory();

From 85728d176fffdcfb3aad3867a7b5e89dba4936f1 Mon Sep 17 00:00:00 2001
From: Jack Horton <jahorto@microsoft.com>
Date: Mon, 5 Feb 2018 11:00:33 -0800
Subject: [PATCH 163/183] test: convert new tests to use error types

PR-URL: https://github.com/nodejs/node/pull/18581
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 test/addons-napi/test_typedarray/test.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/addons-napi/test_typedarray/test.js b/test/addons-napi/test_typedarray/test.js
index 4a4e79ebe7bcdb..4c139d92200fe3 100644
--- a/test/addons-napi/test_typedarray/test.js
+++ b/test/addons-napi/test_typedarray/test.js
@@ -60,7 +60,7 @@ arrayTypes.forEach((currentType) => {
   const template = Reflect.construct(currentType, buffer);
   assert.throws(() => {
     test_typedarray.CreateTypedArray(template, buffer, 0, 136);
-  }, /Invalid typed array length/);
+  }, RangeError);
 });
 
 const nonByteArrayTypes = [ Int16Array, Uint16Array, Int32Array, Uint32Array,
@@ -71,5 +71,5 @@ nonByteArrayTypes.forEach((currentType) => {
     test_typedarray.CreateTypedArray(template, buffer,
                                      currentType.BYTES_PER_ELEMENT + 1, 1);
     console.log(`start of offset ${currentType}`);
-  }, /start offset of/);
+  }, RangeError);
 });

From 495077256e0da9251d79568383332df8397259f4 Mon Sep 17 00:00:00 2001
From: Aonghus O Nia <aonghusonia@eircom.net>
Date: Thu, 8 Feb 2018 17:01:23 -0500
Subject: [PATCH 164/183] doc: fix exporting a function example
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Missing the length argument in napi_create_function.

PR-URL: https://github.com/nodejs/node/pull/18661
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
---
 doc/api/n-api.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index d965f3a4693884..650c4f96baf9eb 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -916,7 +916,7 @@ For example, to set a function to be returned by the `require()` for the addon:
 napi_value Init(napi_env env, napi_value exports) {
   napi_value method;
   napi_status status;
-  status = napi_create_function(env, "exports", Method, NULL, &method);
+  status = napi_create_function(env, "exports", NAPI_AUTO_LENGTH, Method, NULL, &method);
   if (status != napi_ok) return NULL;
   return method;
 }

From 799646388585b62a3b3b0c50b6382a9440b25ac4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tobias=20Nie=C3=9Fen?= <tniessen@tnie.de>
Date: Sat, 10 Feb 2018 16:32:01 +0100
Subject: [PATCH 165/183] doc: mark NAPI_AUTO_LENGTH as code

PR-URL: https://github.com/nodejs/node/pull/18697
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Jeremiah Senkpiel <fishrock123@rocketmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 doc/api/n-api.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 650c4f96baf9eb..cae1dab65ded70 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -552,10 +552,10 @@ NAPI_NO_RETURN void napi_fatal_error(const char* location,
 
 - `[in] location`: Optional location at which the error occurred.
 - `[in] location_len`: The length of the location in bytes, or
-NAPI_AUTO_LENGTH if it is null-terminated.
+`NAPI_AUTO_LENGTH` if it is null-terminated.
 - `[in] message`: The message associated with the error.
 - `[in] message_len`: The length of the message in bytes, or
-NAPI_AUTO_LENGTH if it is
+`NAPI_AUTO_LENGTH` if it is
 null-terminated.
 
 The function call does not return, the process will be terminated.
@@ -1258,7 +1258,7 @@ napi_status napi_create_function(napi_env env,
 - `[in] utf8name`: A string representing the name of the function encoded as
 UTF8.
 - `[in] length`: The length of the utf8name in bytes, or
-NAPI_AUTO_LENGTH if it is null-terminated.
+`NAPI_AUTO_LENGTH` if it is null-terminated.
 - `[in] cb`: A function pointer to the native function to be invoked when the
 created function is invoked from JavaScript.
 - `[in] data`: Optional arbitrary context data to be passed into the native
@@ -1491,7 +1491,7 @@ napi_status napi_create_string_latin1(napi_env env,
 - `[in] env`: The environment that the API is invoked under.
 - `[in] str`: Character buffer representing a ISO-8859-1-encoded string.
 - `[in] length`: The length of the string in bytes, or
-NAPI_AUTO_LENGTH if it is null-terminated.
+`NAPI_AUTO_LENGTH` if it is null-terminated.
 - `[out] result`: A `napi_value` representing a JavaScript String.
 
 Returns `napi_ok` if the API succeeded.
@@ -1516,7 +1516,7 @@ napi_status napi_create_string_utf16(napi_env env,
 - `[in] env`: The environment that the API is invoked under.
 - `[in] str`: Character buffer representing a UTF16-LE-encoded string.
 - `[in] length`: The length of the string in two-byte code units, or
-NAPI_AUTO_LENGTH if it is null-terminated.
+`NAPI_AUTO_LENGTH` if it is null-terminated.
 - `[out] result`: A `napi_value` representing a JavaScript String.
 
 Returns `napi_ok` if the API succeeded.
@@ -1540,7 +1540,7 @@ napi_status napi_create_string_utf8(napi_env env,
 
 - `[in] env`: The environment that the API is invoked under.
 - `[in] str`: Character buffer representing a UTF8-encoded string.
-- `[in] length`: The length of the string in bytes, or NAPI_AUTO_LENGTH
+- `[in] length`: The length of the string in bytes, or `NAPI_AUTO_LENGTH`
 if it is null-terminated.
 - `[out] result`: A `napi_value` representing a JavaScript String.
 
@@ -3066,7 +3066,7 @@ napi_status napi_define_class(napi_env env,
  - `[in] utf8name`: Name of the JavaScript constructor function; this is
    not required to be the same as the C++ class name, though it is recommended
    for clarity.
- - `[in] length`: The length of the utf8name in bytes, or NAPI_AUTO_LENGTH
+ - `[in] length`: The length of the utf8name in bytes, or `NAPI_AUTO_LENGTH`
 if it is null-terminated.
  - `[in] constructor`: Callback function that handles constructing instances
    of the class. (This should be a static method on the class, not an actual

From a12f442c0f1e3469cbb73f2101f4ae18d01f6e22 Mon Sep 17 00:00:00 2001
From: cjihrig <cjihrig@gmail.com>
Date: Sun, 11 Feb 2018 17:07:39 -0500
Subject: [PATCH 166/183] test: remove unnecessary timer

The timer in NAPI's test_callback_scope/test-resolve-async.js
can be removed. If the test fails, it will timeout on its own.
The extra timer increases the chances of the test being
flaky.

PR-URL: https://github.com/nodejs/node/pull/18719
Fixes: https://github.com/nodejs/node/issues/18702
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Santiago Gimeno <santiago.gimeno@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 .../test_callback_scope/test-resolve-async.js            | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/test/addons-napi/test_callback_scope/test-resolve-async.js b/test/addons-napi/test_callback_scope/test-resolve-async.js
index e9f4b9044c0154..77f25c9dde533f 100644
--- a/test/addons-napi/test_callback_scope/test-resolve-async.js
+++ b/test/addons-napi/test_callback_scope/test-resolve-async.js
@@ -1,13 +1,6 @@
 'use strict';
 
 const common = require('../../common');
-const assert = require('assert');
 const { testResolveAsync } = require(`./build/${common.buildType}/binding`);
 
-let called = false;
-testResolveAsync().then(common.mustCall(() => {
-  called = true;
-}));
-
-setTimeout(common.mustCall(() => { assert(called); }),
-           common.platformTimeout(20));
+testResolveAsync().then(common.mustCall());

From 87863351b50e22d537c7b44fd238d883d4d9f0c9 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Tue, 27 Feb 2018 13:02:24 -0500
Subject: [PATCH 167/183] n-api: fix object test

Passing a pointer to a static integer is sufficient for the test.

PR-URL: https://github.com/nodejs/node/pull/19039
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: Hitesh Kanwathirtha <hiteshk@microsoft.com>
---
 test/addons-napi/test_object/test_object.c | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/test/addons-napi/test_object/test_object.c b/test/addons-napi/test_object/test_object.c
index 75e0ee4c30f85c..a84da27365ff2e 100644
--- a/test/addons-napi/test_object/test_object.c
+++ b/test/addons-napi/test_object/test_object.c
@@ -1,7 +1,6 @@
 #include <node_api.h>
 #include "../common.h"
 #include <string.h>
-#include <stdlib.h>
 
 static int test_value = 3;
 
@@ -199,9 +198,7 @@ napi_value Wrap(napi_env env, napi_callback_info info) {
   napi_value arg;
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &arg, NULL, NULL));
 
-  int32_t* data = malloc(sizeof(int32_t));
-  *data = test_value;
-  NAPI_CALL(env, napi_wrap(env, arg, data, NULL, NULL, NULL));
+  NAPI_CALL(env, napi_wrap(env, arg, &test_value, NULL, NULL, NULL));
   return NULL;
 }
 

From 0efd8267fcc6e0f7228092f87f9701f9c00fff32 Mon Sep 17 00:00:00 2001
From: Eric Bickle <wolf.code@outlook.com>
Date: Thu, 1 Mar 2018 09:27:16 -0800
Subject: [PATCH 168/183] doc: fix n-api asynchronous threading docs

Documentation for N-API Custom Asynchronous Operations incorrectly
stated that async execution happens on the main event loop.
Added details to napi_create_async_work about which threads are
used to invoke the execute and complete callbacks.

Changed 'async' to 'asynchronous' in the documentation for Custom
Asynchronous Operations. Changed "executes in parallel" to "can
execute in parallel" for the documentation of napi_create_async_work
execute parameter.

PR-URL: https://github.com/nodejs/node/pull/19073
Fixes: https://github.com/nodejs/node/issues/19071
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 doc/api/n-api.md | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index cae1dab65ded70..4c555554405331 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -3281,9 +3281,11 @@ napi_status napi_create_async_work(napi_env env,
 - `[in] async_resource_name`: Identifier for the kind of resource that is
 being provided for diagnostic information exposed by the `async_hooks` API.
 - `[in] execute`: The native function which should be called to excute
-the logic asynchronously.
+the logic asynchronously. The given function is called from a worker pool
+thread and can execute in parallel with the main event loop thread.
 - `[in] complete`: The native function which will be called when the
-asynchronous logic is comple or is cancelled.
+asynchronous logic is completed or is cancelled. The given function is called
+from the main event loop thread.
 - `[in] data`: User-provided data context. This will be passed back into the
 execute and complete functions.
 - `[out] result`: `napi_async_work*` which is the handle to the newly created
@@ -3359,9 +3361,9 @@ callback invocation, even if it has been successfully cancelled.
 
 ## Custom Asynchronous Operations
 The simple asynchronous work APIs above may not be appropriate for every
-scenario, because with those the async execution still happens on the main
-event loop. When using any other async mechanism, the following APIs are
-necessary to ensure an async operation is properly tracked by the runtime.
+scenario. When using any other asynchronous mechanism, the following APIs
+are necessary to ensure an asynchronous operation is properly tracked by
+the runtime.
 
 ### napi_async_init
 <!-- YAML

From cab6ce9c51966237c6d5d0e745301182bebab133 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Fri, 2 Mar 2018 09:41:12 -0500
Subject: [PATCH 169/183] n-api: update reference test
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Remove the necessity for allocating on the heap, and assert that the
correct pointer gets passed to the finalizer.

PR-URL: https://github.com/nodejs/node/pull/19086
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 test/addons-napi/test_reference/test_reference.c | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/test/addons-napi/test_reference/test_reference.c b/test/addons-napi/test_reference/test_reference.c
index 9f25eddb313bef..329d1bb18b6a09 100644
--- a/test/addons-napi/test_reference/test_reference.c
+++ b/test/addons-napi/test_reference/test_reference.c
@@ -1,6 +1,5 @@
 #include <node_api.h>
 #include "../common.h"
-#include <stdlib.h>
 
 static int test_value = 1;
 static int finalize_count = 0;
@@ -13,7 +12,9 @@ napi_value GetFinalizeCount(napi_env env, napi_callback_info info) {
 }
 
 void FinalizeExternal(napi_env env, void* data, void* hint) {
-  free(data);
+  int *actual_value = data;
+  NAPI_ASSERT_RETURN_VOID(env, actual_value == &test_value,
+      "The correct pointer was passed to the finalizer");
   finalize_count++;
 }
 
@@ -33,13 +34,10 @@ napi_value CreateExternal(napi_env env, napi_callback_info info) {
 }
 
 napi_value CreateExternalWithFinalize(napi_env env, napi_callback_info info) {
-  int* data = malloc(sizeof(int));
-  *data = test_value;
-
   napi_value result;
   NAPI_CALL(env,
       napi_create_external(env,
-                           data,
+                           &test_value,
                            FinalizeExternal,
                            NULL, /* finalize_hint */
                            &result));

From ab4763d117d3fd3585abd0130c34183fe12e7070 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Thu, 1 Mar 2018 17:44:51 -0500
Subject: [PATCH 170/183] n-api: update documentation

Document which APIs work while an exception is pending. This is the
list of all APIs which do not start with `NAPI_PREAMBLE(env)`.

Fixes: https://github.com/nodejs/abi-stable-node/issues/257
PR-URL: https://github.com/nodejs/node/pull/19078
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 doc/api/n-api.md | 36 ++++++++++++++++++++++++++----------
 1 file changed, 26 insertions(+), 10 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 4c555554405331..2345a14fe4d169 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -277,6 +277,8 @@ valid up until an n-api function is called on the same `env`.
 information as it is not subject to SemVer and may change at any time.
 It is intended only for logging purposes.
 
+This API can be called even if there is a pending JavaScript exception.
+
 
 ### Exceptions
 Any N-API function call may result in a pending JavaScript exception. This is
@@ -502,7 +504,6 @@ Returns `napi_ok` if the API succeeded.
 
 This API returns a JavaScript RangeError with the text provided.
 
-
 #### napi_get_and_clear_last_exception
 <!-- YAML
 added: v8.0.0
@@ -519,6 +520,8 @@ Returns `napi_ok` if the API succeeded.
 
 This API returns true if an exception is pending.
 
+This API can be called even if there is a pending JavaScript exception.
+
 #### napi_is_exception_pending
 <!-- YAML
 added: v8.0.0
@@ -534,6 +537,8 @@ Returns `napi_ok` if the API succeeded.
 
 This API returns true if an exception is pending.
 
+This API can be called even if there is a pending JavaScript exception.
+
 ### Fatal Errors
 
 In the event of an unrecoverable error in a native module, a fatal error can be
@@ -560,6 +565,8 @@ null-terminated.
 
 The function call does not return, the process will be terminated.
 
+This API can be called even if there is a pending JavaScript exception.
+
 ## Object Lifetime management
 
 As N-API calls are made, handles to objects in the heap for the underlying
@@ -680,6 +687,8 @@ Returns `napi_ok` if the API succeeded.
 This API closes the scope passed in. Scopes must be closed in the
 reverse order from which they were created.
 
+This API can be called even if there is a pending JavaScript exception.
+
 #### napi_open_escapable_handle_scope
 <!-- YAML
 added: v8.0.0
@@ -714,6 +723,8 @@ Returns `napi_ok` if the API succeeded.
 This API closes the scope passed in. Scopes must be closed in the
 reverse order from which they were created.
 
+This API can be called even if there is a pending JavaScript exception.
+
 #### napi_escape_handle
 <!-- YAML
 added: v8.0.0
@@ -737,7 +748,10 @@ This API promotes the handle to the JavaScript object so that it is valid
 for the lifetime of the outer scope. It can only be called once per scope.
 If it is called more than once an error will be returned.
 
+This API can be called even if there is a pending JavaScript exception.
+
 ### References to objects with a lifespan longer than that of the native method
+
 In some cases an addon will need to be able to create and reference objects
 with a lifespan longer than that of a single native method invocation. For
 example, to create a constructor and later use that constructor
@@ -812,6 +826,8 @@ Returns `napi_ok` if the API succeeded.
 
 This API deletes the reference passed in.
 
+This API can be called even if there is a pending JavaScript exception.
+
 #### napi_reference_ref
 <!-- YAML
 added: v8.0.0
@@ -830,7 +846,6 @@ Returns `napi_ok` if the API succeeded.
 This API increments the reference count for the reference
 passed in and returns the resulting reference count.
 
-
 #### napi_reference_unref
 <!-- YAML
 added: v8.0.0
@@ -849,7 +864,6 @@ Returns `napi_ok` if the API succeeded.
 This API decrements the reference count for the reference
 passed in and returns the resulting reference count.
 
-
 #### napi_get_reference_value
 <!-- YAML
 added: v8.0.0
@@ -1676,8 +1690,6 @@ This API returns various properties of a typed array.
 *Warning*: Use caution while using this API since the underlying data buffer
 is managed by the VM
 
-
-
 #### napi_get_dataview_info
 <!-- YAML
 added: REPLACEME
@@ -1705,7 +1717,6 @@ Returns `napi_ok` if the API succeeded.
 
 This API returns various properties of a DataView.
 
-
 #### napi_get_value_bool
 <!-- YAML
 added: v8.0.0
@@ -1746,7 +1757,6 @@ in it returns `napi_number_expected`.
 This API returns the C double primitive equivalent of the given JavaScript
 Number.
 
-
 #### napi_get_value_external
 <!-- YAML
 added: v8.0.0
@@ -1808,7 +1818,7 @@ Returns `napi_ok` if the API succeeded. If a non-number `napi_value`
 is passed in it returns `napi_number_expected`.
 
 This API returns the C int64 primitive equivalent of the given
-JavaScript Number
+JavaScript Number.
 
 #### napi_get_value_string_latin1
 <!-- YAML
@@ -2200,8 +2210,6 @@ Returns `napi_ok` if the API succeeded.
 
 This API checks if the Object passsed in is a typed array.
 
-
-
 ### napi_is_dataview
 <!-- YAML
 added: REPLACEME
@@ -3321,6 +3329,8 @@ Returns `napi_ok` if the API succeeded.
 
 This API frees a previously allocated work object.
 
+This API can be called even if there is a pending JavaScript exception.
+
 ### napi_queue_async_work
 <!-- YAML
 added: v8.0.0
@@ -3359,6 +3369,8 @@ the `complete` callback will be invoked with a status value of
 `napi_cancelled`. The work should not be deleted before the `complete`
 callback invocation, even if it has been successfully cancelled.
 
+This API can be called even if there is a pending JavaScript exception.
+
 ## Custom Asynchronous Operations
 The simple asynchronous work APIs above may not be appropriate for every
 scenario. When using any other asynchronous mechanism, the following APIs
@@ -3400,6 +3412,8 @@ napi_status napi_async_destroy(napi_env env,
 
 Returns `napi_ok` if the API succeeded.
 
+This API can be called even if there is a pending JavaScript exception.
+
 ### napi_make_callback
 <!-- YAML
 added: v8.0.0
@@ -3482,6 +3496,8 @@ NAPI_EXTERN napi_status napi_close_callback_scope(napi_env env,
 - `[in] env`: The environment that the API is invoked under.
 - `[in] scope`: The scope to be closed.
 
+This API can be called even if there is a pending JavaScript exception.
+
 ## Version Management
 
 ### napi_get_node_version

From a5ec82fdd66784922919a394a227639bdacf0799 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Thu, 8 Mar 2018 18:17:46 -0500
Subject: [PATCH 171/183] n-api: resolve promise in test

The last promise created by the test for the purposes of making sure
that its type is indeed a promise needs to be resolved so as to avoid
having it left in the pending state at the end of the test.

PR-URL: https://github.com/nodejs/node/pull/19245
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 test/addons-napi/test_promise/test.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/addons-napi/test_promise/test.js b/test/addons-napi/test_promise/test.js
index 6dc51b3fa558a2..477ceb75969d51 100644
--- a/test/addons-napi/test_promise/test.js
+++ b/test/addons-napi/test_promise/test.js
@@ -45,7 +45,9 @@ common.crashOnUnhandledRejection();
   test_promise.concludeCurrentPromise(Promise.resolve('chained answer'), true);
 }
 
-assert.strictEqual(test_promise.isPromise(test_promise.createPromise()), true);
+const promiseTypeTestPromise = test_promise.createPromise();
+assert.strictEqual(test_promise.isPromise(promiseTypeTestPromise), true);
+test_promise.concludeCurrentPromise(undefined, true);
 
 const rejectPromise = Promise.reject(-1);
 const expected_reason = -1;

From b0e458ac7934d2725cbc5fd6d76a2b5f60398476 Mon Sep 17 00:00:00 2001
From: Taylor Woll <taylor.woll@microsoft.com>
Date: Tue, 16 Jan 2018 21:17:25 -0800
Subject: [PATCH 172/183] n-api,test: add a new.target test to addons-napi

Added a N-API test to verify new.target behavior.

PR-URL: https://github.com/nodejs/node/pull/19236
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 test/addons-napi/test_new_target/binding.c   | 69 ++++++++++++++++++++
 test/addons-napi/test_new_target/binding.gyp |  9 +++
 test/addons-napi/test_new_target/test.js     | 21 ++++++
 3 files changed, 99 insertions(+)
 create mode 100644 test/addons-napi/test_new_target/binding.c
 create mode 100644 test/addons-napi/test_new_target/binding.gyp
 create mode 100644 test/addons-napi/test_new_target/test.js

diff --git a/test/addons-napi/test_new_target/binding.c b/test/addons-napi/test_new_target/binding.c
new file mode 100644
index 00000000000000..a74d4bb2f877be
--- /dev/null
+++ b/test/addons-napi/test_new_target/binding.c
@@ -0,0 +1,69 @@
+#include <node_api.h>
+#include "../common.h"
+
+napi_value BaseClass(napi_env env, napi_callback_info info) {
+  napi_value newTargetArg;
+  NAPI_CALL(env, napi_get_new_target(env, info, &newTargetArg));
+  napi_value thisArg;
+  NAPI_CALL(env, napi_get_cb_info(env, info, NULL, NULL, &thisArg, NULL));
+  napi_value undefined;
+  NAPI_CALL(env, napi_get_undefined(env, &undefined));
+
+  // this !== new.target since we are being invoked through super()
+  bool result;
+  NAPI_CALL(env, napi_strict_equals(env, newTargetArg, thisArg, &result));
+  NAPI_ASSERT(env, !result, "this !== new.target");
+
+  // new.target !== undefined because we should be called as a new expression
+  NAPI_ASSERT(env, newTargetArg != NULL, "newTargetArg != NULL");
+  NAPI_CALL(env, napi_strict_equals(env, newTargetArg, undefined, &result));
+  NAPI_ASSERT(env, !result, "new.target !== undefined");
+
+  return thisArg;
+}
+
+napi_value Constructor(napi_env env, napi_callback_info info) {
+  bool result;
+  napi_value newTargetArg;
+  NAPI_CALL(env, napi_get_new_target(env, info, &newTargetArg));
+  size_t argc = 1;
+  napi_value argv;
+  napi_value thisArg;
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &argv, &thisArg, NULL));
+  napi_value undefined;
+  NAPI_CALL(env, napi_get_undefined(env, &undefined));
+
+  // new.target !== undefined because we should be called as a new expression
+  NAPI_ASSERT(env, newTargetArg != NULL, "newTargetArg != NULL");
+  NAPI_CALL(env, napi_strict_equals(env, newTargetArg, undefined, &result));
+  NAPI_ASSERT(env, !result, "new.target !== undefined");
+
+  // arguments[0] should be Constructor itself (test harness passed it)
+  NAPI_CALL(env, napi_strict_equals(env, newTargetArg, argv, &result));
+  NAPI_ASSERT(env, result, "new.target === Constructor");
+
+  return thisArg;
+}
+
+napi_value OrdinaryFunction(napi_env env, napi_callback_info info) {
+  napi_value newTargetArg;
+  NAPI_CALL(env, napi_get_new_target(env, info, &newTargetArg));
+
+  NAPI_ASSERT(env, newTargetArg == NULL, "newTargetArg == NULL");
+
+  napi_value _true;
+  NAPI_CALL(env, napi_get_boolean(env, true, &_true));
+  return _true;
+}
+
+napi_value Init(napi_env env, napi_value exports) {
+  const napi_property_descriptor desc[] = {
+    DECLARE_NAPI_PROPERTY("BaseClass", BaseClass),
+    DECLARE_NAPI_PROPERTY("OrdinaryFunction", OrdinaryFunction),
+    DECLARE_NAPI_PROPERTY("Constructor", Constructor)
+  };
+  NAPI_CALL(env, napi_define_properties(env, exports, 3, desc));
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
diff --git a/test/addons-napi/test_new_target/binding.gyp b/test/addons-napi/test_new_target/binding.gyp
new file mode 100644
index 00000000000000..23daf507916ff6
--- /dev/null
+++ b/test/addons-napi/test_new_target/binding.gyp
@@ -0,0 +1,9 @@
+{
+  'targets': [
+    {
+      'target_name': 'binding',
+      'defines': [ 'V8_DEPRECATION_WARNINGS=1' ],
+      'sources': [ 'binding.c' ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_new_target/test.js b/test/addons-napi/test_new_target/test.js
new file mode 100644
index 00000000000000..702e8ca8b4387d
--- /dev/null
+++ b/test/addons-napi/test_new_target/test.js
@@ -0,0 +1,21 @@
+'use strict';
+
+const common = require('../../common');
+const assert = require('assert');
+const binding = require(`./build/${common.buildType}/binding`);
+
+class Class extends binding.BaseClass {
+  constructor() {
+    super();
+    this.method();
+  }
+  method() {
+    this.ok = true;
+  }
+}
+
+assert.ok(new Class() instanceof binding.BaseClass);
+assert.ok(new Class().ok);
+assert.ok(binding.OrdinaryFunction());
+assert.ok(
+  new binding.Constructor(binding.Constructor) instanceof binding.Constructor);

From f07b614653ca930642deee140becf7365cad0a5f Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Tue, 10 Apr 2018 17:45:35 -0400
Subject: [PATCH 173/183] n-api: take n-api out of experimental
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Take n-api out of experimental as per:
https://github.com/nodejs/TSC/issues/501

PR-URL: https://github.com/nodejs/node/pull/19262
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Gus Caplan <me@gus.host>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
---
 src/env-inl.h                                 |  1 -
 src/env.cc                                    |  6 ------
 src/env.h                                     |  3 ---
 src/node.cc                                   |  9 +++------
 src/node_api.cc                               | 10 ----------
 src/node_api.h                                |  9 ---------
 test/addons-napi/test_warning/binding.gyp     | 12 ------------
 test/addons-napi/test_warning/test.js         | 16 ----------------
 test/addons-napi/test_warning/test_warning.c  | 11 -----------
 test/addons-napi/test_warning/test_warning2.c | 11 -----------
 10 files changed, 3 insertions(+), 85 deletions(-)
 delete mode 100644 test/addons-napi/test_warning/binding.gyp
 delete mode 100644 test/addons-napi/test_warning/test.js
 delete mode 100644 test/addons-napi/test_warning/test_warning.c
 delete mode 100644 test/addons-napi/test_warning/test_warning2.c

diff --git a/src/env-inl.h b/src/env-inl.h
index 9b4000d75b180d..a5e2e176c11df3 100644
--- a/src/env-inl.h
+++ b/src/env-inl.h
@@ -223,7 +223,6 @@ inline Environment::Environment(v8::Local<v8::Context> context,
       using_domains_(false),
       printed_error_(false),
       trace_sync_io_(false),
-      emit_napi_warning_(true),
       makecallback_cntr_(0),
       async_wrap_uid_(0),
       debugger_agent_(this),
diff --git a/src/env.cc b/src/env.cc
index 0b31afdf2eaf23..5090475499dcaf 100644
--- a/src/env.cc
+++ b/src/env.cc
@@ -61,10 +61,4 @@ void Environment::PrintSyncTrace() const {
   fflush(stderr);
 }
 
-bool Environment::EmitNapiWarning() {
-  bool current_value = emit_napi_warning_;
-  emit_napi_warning_ = false;
-  return current_value;
-}
-
 }  // namespace node
diff --git a/src/env.h b/src/env.h
index 593f38964c7839..19c6e84642a963 100644
--- a/src/env.h
+++ b/src/env.h
@@ -537,8 +537,6 @@ class Environment {
 
   static const int kContextEmbedderDataIndex = NODE_CONTEXT_EMBEDDER_DATA_INDEX;
 
-  bool EmitNapiWarning();
-
  private:
   inline void ThrowError(v8::Local<v8::Value> (*fun)(v8::Local<v8::String>),
                          const char* errmsg);
@@ -570,7 +568,6 @@ class Environment {
   bool using_domains_;
   bool printed_error_;
   bool trace_sync_io_;
-  bool emit_napi_warning_;
   size_t makecallback_cntr_;
   int64_t async_wrap_uid_;
   std::vector<int64_t> destroy_ids_list_;
diff --git a/src/node.cc b/src/node.cc
index 05f34be823d9cf..3f4c02413c9aa7 100644
--- a/src/node.cc
+++ b/src/node.cc
@@ -2500,12 +2500,9 @@ void DLOpen(const FunctionCallbackInfo<Value>& args) {
     env->ThrowError("Module did not self-register.");
     return;
   }
-  if (mp->nm_version == -1) {
-    if (env->EmitNapiWarning()) {
-      ProcessEmitWarning(env, "N-API is an experimental feature and could "
-                         "change at any time.");
-    }
-  } else if (mp->nm_version != NODE_MODULE_VERSION) {
+
+  // -1 is used for N-API modules
+  if ((mp->nm_version != -1) && (mp->nm_version != NODE_MODULE_VERSION)) {
     char errmsg[1024];
     snprintf(errmsg,
              sizeof(errmsg),
diff --git a/src/node_api.cc b/src/node_api.cc
index a5902db0454eba..8c454d6425889d 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -1,13 +1,3 @@
-/******************************************************************************
- * Experimental prototype for demonstrating VM agnostic and ABI stable API
- * for native modules to use instead of using Nan and V8 APIs directly.
- *
- * The current status is "Experimental" and should not be used for
- * production applications.  The API is still subject to change
- * and as an experimental feature is NOT subject to semver.
- *
- ******************************************************************************/
-
 #include <node_buffer.h>
 #include <node_object_wrap.h>
 #include <limits.h>  // INT_MAX
diff --git a/src/node_api.h b/src/node_api.h
index 3b741c27b976ae..c5b8a2a30cfe15 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -1,12 +1,3 @@
-/******************************************************************************
- * Experimental prototype for demonstrating VM agnostic and ABI stable API
- * for native modules to use instead of using Nan and V8 APIs directly.
- *
- * The current status is "Experimental" and should not be used for
- * production applications.  The API is still subject to change
- * and as an experimental feature is NOT subject to semver.
- *
- ******************************************************************************/
 #ifndef SRC_NODE_API_H_
 #define SRC_NODE_API_H_
 
diff --git a/test/addons-napi/test_warning/binding.gyp b/test/addons-napi/test_warning/binding.gyp
deleted file mode 100644
index a44593e2518c24..00000000000000
--- a/test/addons-napi/test_warning/binding.gyp
+++ /dev/null
@@ -1,12 +0,0 @@
-{
-  "targets": [
-    {
-      "target_name": "test_warning",
-      "sources": [ "test_warning.c" ]
-    },
-    {
-      "target_name": "test_warning2",
-      "sources": [ "test_warning2.c" ]
-    }
-  ]
-}
diff --git a/test/addons-napi/test_warning/test.js b/test/addons-napi/test_warning/test.js
deleted file mode 100644
index c82008435fd8fd..00000000000000
--- a/test/addons-napi/test_warning/test.js
+++ /dev/null
@@ -1,16 +0,0 @@
-'use strict';
-
-if (process.argv[2] === 'child') {
-  const common = require('../../common');
-  console.log(require(`./build/${common.buildType}/test_warning`));
-  console.log(require(`./build/${common.buildType}/test_warning2`));
-} else {
-  const run = require('child_process').spawnSync;
-  const assert = require('assert');
-  const warning = 'Warning: N-API is an experimental feature and could ' +
-                  'change at any time.';
-
-  const result = run(process.execPath, [__filename, 'child']);
-  assert.deepStrictEqual(result.stdout.toString().match(/\S+/g), ['42', '1337']);
-  assert.deepStrictEqual(result.stderr.toString().split(warning).length, 2);
-}
diff --git a/test/addons-napi/test_warning/test_warning.c b/test/addons-napi/test_warning/test_warning.c
deleted file mode 100644
index d0821be1f2268d..00000000000000
--- a/test/addons-napi/test_warning/test_warning.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <node_api.h>
-#include "../common.h"
-
-napi_value Init(napi_env env, napi_value exports) {
-  napi_value result;
-  NAPI_CALL(env,
-    napi_create_uint32(env, 42, &result));
-  return result;
-}
-
-NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)
diff --git a/test/addons-napi/test_warning/test_warning2.c b/test/addons-napi/test_warning/test_warning2.c
deleted file mode 100644
index 3c8ee9db01390b..00000000000000
--- a/test/addons-napi/test_warning/test_warning2.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <node_api.h>
-#include "../common.h"
-
-napi_value Init(napi_env env, napi_value exports) {
-  napi_value result;
-  NAPI_CALL(env,
-    napi_create_uint32(env, 1337, &result));
-  return result;
-}
-
-NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)

From fdd3f5795084267605e5e666d042eeefe9bcbe17 Mon Sep 17 00:00:00 2001
From: Kyle Farnung <kfarnung@microsoft.com>
Date: Mon, 12 Mar 2018 13:36:29 -0700
Subject: [PATCH 174/183] n-api,test: add int64 bounds tests

Added some simple tests to verify that the int64 API is correctly
handling numbers greater than 32-bits. This is a basic test, but
verifies that an implementer hasn't truncated back to 32-bits.

Refs: https://github.com/nodejs/node-chakracore/pull/496

PR-URL: https://github.com/nodejs/node/pull/19309
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Gabriel Schulhof <gabriel.schulhof@intel.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/addons-napi/test_number/test.js       |  7 +++++++
 test/addons-napi/test_number/test_number.c | 23 ++++++++++++++++++++++
 2 files changed, 30 insertions(+)

diff --git a/test/addons-napi/test_number/test.js b/test/addons-napi/test_number/test.js
index b8ce6b7f995b66..f9d6eb6a6f307a 100644
--- a/test/addons-napi/test_number/test.js
+++ b/test/addons-napi/test_number/test.js
@@ -45,3 +45,10 @@ assert.strictEqual(1, test_number.TestInt32Truncation(4294967297));
 assert.strictEqual(0, test_number.TestInt32Truncation(4294967296));
 assert.strictEqual(-1, test_number.TestInt32Truncation(4294967295));
 assert.strictEqual(3, test_number.TestInt32Truncation(4294967296 * 5 + 3));
+
+// validate that the boundaries of safe integer can be passed through
+// successfully
+assert.strictEqual(Number.MAX_SAFE_INTEGER,
+                   test_number.TestInt64Truncation(Number.MAX_SAFE_INTEGER));
+assert.strictEqual(Number.MIN_SAFE_INTEGER,
+                   test_number.TestInt64Truncation(Number.MIN_SAFE_INTEGER));
diff --git a/test/addons-napi/test_number/test_number.c b/test/addons-napi/test_number/test_number.c
index d88b1d8b23447b..35223dc3d878da 100644
--- a/test/addons-napi/test_number/test_number.c
+++ b/test/addons-napi/test_number/test_number.c
@@ -45,10 +45,33 @@ napi_value TestInt32Truncation(napi_env env, napi_callback_info info) {
   return output;
 }
 
+napi_value TestInt64Truncation(napi_env env, napi_callback_info info) {
+  size_t argc = 1;
+  napi_value args[1];
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
+
+  NAPI_ASSERT(env, argc >= 1, "Wrong number of arguments");
+
+  napi_valuetype valuetype0;
+  NAPI_CALL(env, napi_typeof(env, args[0], &valuetype0));
+
+  NAPI_ASSERT(env, valuetype0 == napi_number,
+      "Wrong type of arguments. Expects a number as first argument.");
+
+  int64_t input;
+  NAPI_CALL(env, napi_get_value_int64(env, args[0], &input));
+
+  napi_value output;
+  NAPI_CALL(env, napi_create_int64(env, input, &output));
+
+  return output;
+}
+
 napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("Test", Test),
     DECLARE_NAPI_PROPERTY("TestInt32Truncation", TestInt32Truncation),
+    DECLARE_NAPI_PROPERTY("TestInt64Truncation", TestInt64Truncation),
   };
 
   NAPI_CALL(env, napi_define_properties(

From 7c784de00f8d49328ccf078df5a7c55ceb727ec6 Mon Sep 17 00:00:00 2001
From: Kyle Robinson Young <kyle@dontkry.com>
Date: Thu, 15 Mar 2018 22:57:15 -0700
Subject: [PATCH 175/183] doc: fix typos on n-api
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/19385
Reviewed-By: Gireesh Punathil <gpunathi@in.ibm.com>
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Richard Lau <riclau@uk.ibm.com>
Reviewed-By: Vse Mozhet Byt <vsemozhetbyt@gmail.com>
Reviewed-By: Tobias Nießen <tniessen@tnie.de>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 doc/api/n-api.md | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 2345a14fe4d169..91cf0147972ba1 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -613,7 +613,7 @@ are no longer required, the scope can be 'closed' and any handles associated
 with the scope are invalidated. The methods available to open/close scopes are
 [`napi_open_handle_scope`][] and [`napi_close_handle_scope`][].
 
-N-API only supports a single nested hiearchy of scopes. There is only one
+N-API only supports a single nested hierarchy of scopes. There is only one
 active scope at any time, and all new handles will be associated with that
 scope while it is active. Scopes must be closed in the reverse order from
 which they are opened. In addition, all scopes created within a native method
@@ -884,7 +884,7 @@ object to which the reference is related.
 Returns `napi_ok` if the API succeeded.
 
 If still valid, this API returns the `napi_value` representing the
-JavaScript Object associated with the `napi_ref`. Otherise, result
+JavaScript Object associated with the `napi_ref`. Otherwise, result
 will be NULL.
 
 ## Module registration
@@ -2159,7 +2159,7 @@ napi_status napi_is_arraybuffer(napi_env env, napi_value value, bool* result)
 
 Returns `napi_ok` if the API succeeded.
 
-This API checks if the Object passsed in is an array buffer.
+This API checks if the Object passed in is an array buffer.
 
 ### napi_is_buffer
 <!-- YAML
@@ -2176,7 +2176,7 @@ object.
 
 Returns `napi_ok` if the API succeeded.
 
-This API checks if the Object passsed in is a buffer.
+This API checks if the Object passed in is a buffer.
 
 ### napi_is_error
 <!-- YAML
@@ -2192,7 +2192,7 @@ napi_status napi_is_error(napi_env env, napi_value value, bool* result)
 
 Returns `napi_ok` if the API succeeded.
 
-This API checks if the Object passsed in is an Error.
+This API checks if the Object passed in is an Error.
 
 ### napi_is_typedarray
 <!-- YAML
@@ -2208,7 +2208,7 @@ napi_status napi_is_typedarray(napi_env env, napi_value value, bool* result)
 
 Returns `napi_ok` if the API succeeded.
 
-This API checks if the Object passsed in is a typed array.
+This API checks if the Object passed in is a typed array.
 
 ### napi_is_dataview
 <!-- YAML
@@ -2480,7 +2480,7 @@ and [`napi_get_element`][].
 
 Returns `napi_ok` if the API succeeded.
 
-This API returns the array of propertys for the Object passed in
+This API returns the array of properties for the Object passed in
 
 #### napi_set_property
 <!-- YAML
@@ -3288,7 +3288,7 @@ napi_status napi_create_async_work(napi_env env,
   that will be passed to possible async_hooks [`init` hooks][].
 - `[in] async_resource_name`: Identifier for the kind of resource that is
 being provided for diagnostic information exposed by the `async_hooks` API.
-- `[in] execute`: The native function which should be called to excute
+- `[in] execute`: The native function which should be called to execute
 the logic asynchronously. The given function is called from a worker pool
 thread and can execute in parallel with the main event loop thread.
 - `[in] complete`: The native function which will be called when the

From dd61f8e6acfb9e21025a7af23dea8d28608d7391 Mon Sep 17 00:00:00 2001
From: Michael Dawson <michael_dawson@ca.ibm.com>
Date: Wed, 14 Mar 2018 22:05:47 -0400
Subject: [PATCH 176/183] n-api: add missing exception checking

Add checks for a pending exception in napi_make_callback
after the callback has been invoked.  If there is a pending
exception then we need to avoid checking the result as that
will not be able to complete properly.

Add additional checks to the unit test for napi_make_callback
to catch this case.

PR-URL: https://github.com/nodejs/node/pull/19362
Fixes: https://github.com/nodejs/node-addon-api/issues/235
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
---
 src/node_api.cc                                   | 12 ++++++++----
 .../test_make_callback_recurse/binding.cc         | 15 ++++++++++++++-
 2 files changed, 22 insertions(+), 5 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index 8c454d6425889d..b153aa5f3c3bf6 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -2910,11 +2910,15 @@ napi_status napi_make_callback(napi_env env,
       isolate, v8recv, v8func, argc,
       reinterpret_cast<v8::Local<v8::Value>*>(const_cast<napi_value*>(argv)),
       *node_async_context);
-  CHECK_MAYBE_EMPTY(env, callback_result, napi_generic_failure);
 
-  if (result != nullptr) {
-    *result = v8impl::JsValueFromV8LocalValue(
-        callback_result.ToLocalChecked());
+  if (try_catch.HasCaught()) {
+    return napi_set_last_error(env, napi_pending_exception);
+  } else {
+    CHECK_MAYBE_EMPTY(env, callback_result, napi_generic_failure);
+    if (result != nullptr) {
+      *result = v8impl::JsValueFromV8LocalValue(
+          callback_result.ToLocalChecked());
+    }
   }
 
   return GET_RETURN_STATUS(env);
diff --git a/test/addons-napi/test_make_callback_recurse/binding.cc b/test/addons-napi/test_make_callback_recurse/binding.cc
index c68e924fdb436d..8a32b88b9dec91 100644
--- a/test/addons-napi/test_make_callback_recurse/binding.cc
+++ b/test/addons-napi/test_make_callback_recurse/binding.cc
@@ -12,9 +12,22 @@ napi_value MakeCallback(napi_env env, napi_callback_info info) {
   napi_value recv = args[0];
   napi_value func = args[1];
 
-  napi_make_callback(env, nullptr /* async_context */,
+  napi_status status = napi_make_callback(env, nullptr /* async_context */,
     recv, func, 0 /* argc */, nullptr /* argv */, nullptr /* result */);
 
+  bool isExceptionPending;
+  NAPI_CALL(env, napi_is_exception_pending(env, &isExceptionPending));
+  if (isExceptionPending && !(status == napi_pending_exception)) {
+    // if there is an exception pending we don't expect any
+    // other error
+    napi_value pending_error;
+    status = napi_get_and_clear_last_exception(env, &pending_error);
+    NAPI_CALL(env,
+      napi_throw_error((env),
+                        nullptr,
+                        "error when only pending exception expected"));
+  }
+
   return recv;
 }
 

From 78ccedf35dfad228db57ca51dc6b859b1d7a7ab4 Mon Sep 17 00:00:00 2001
From: Mathias Buus <mathiasbuus@gmail.com>
Date: Wed, 14 Mar 2018 03:14:08 +0100
Subject: [PATCH 177/183] n-api: add napi_fatal_exception

Add function to trigger and uncaught exception.
Useful if an async callback throws an exception with
no way to recover.

PR-URL: https://github.com/nodejs/node/pull/19337
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 doc/api/n-api.md                              | 14 ++++++++++
 src/node_api.cc                               | 24 ++++++++++++++---
 src/node_api.h                                |  2 ++
 src/node_internals.h                          |  5 ++++
 test/addons-napi/test_async/test-uncaught.js  | 18 +++++++++++++
 .../test_fatal_exception/binding.gyp          |  8 ++++++
 test/addons-napi/test_fatal_exception/test.js | 11 ++++++++
 .../test_fatal_exception.c                    | 26 +++++++++++++++++++
 8 files changed, 104 insertions(+), 4 deletions(-)
 create mode 100644 test/addons-napi/test_async/test-uncaught.js
 create mode 100644 test/addons-napi/test_fatal_exception/binding.gyp
 create mode 100644 test/addons-napi/test_fatal_exception/test.js
 create mode 100644 test/addons-napi/test_fatal_exception/test_fatal_exception.c

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 91cf0147972ba1..4245c28fb046c0 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -539,6 +539,20 @@ This API returns true if an exception is pending.
 
 This API can be called even if there is a pending JavaScript exception.
 
+#### napi_fatal_exception
+<!-- YAML
+added: REPLACEME
+-->
+```C
+napi_status napi_fatal_exception(napi_env env, napi_value err);
+```
+
+- `[in] env`: The environment that the API is invoked under.
+- `[in] err`: The error you want to pass to `uncaughtException`.
+
+Trigger an `uncaughtException` in JavaScript. Useful if an async
+callback throws an exception with no way to recover.
+
 ### Fatal Errors
 
 In the event of an unrecoverable error in a native module, a fatal error can be
diff --git a/src/node_api.cc b/src/node_api.cc
index b153aa5f3c3bf6..a52ecef27c4c27 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -293,6 +293,13 @@ v8::Local<v8::Value> V8LocalValueFromJsValue(napi_value v) {
   return local;
 }
 
+static inline void trigger_fatal_exception(
+    napi_env env, v8::Local<v8::Value> local_err) {
+  v8::Local<v8::Message> local_msg =
+    v8::Exception::CreateMessage(env->isolate, local_err);
+  node::FatalException(env->isolate, local_err, local_msg);
+}
+
 static inline napi_status V8NameFromPropertyDescriptor(napi_env env,
                                          const napi_property_descriptor* p,
                                          v8::Local<v8::Name>* result) {
@@ -967,6 +974,16 @@ napi_status napi_get_last_error_info(napi_env env,
   return napi_ok;
 }
 
+napi_status napi_fatal_exception(napi_env env, napi_value err) {
+  NAPI_PREAMBLE(env);
+  CHECK_ARG(env, err);
+
+  v8::Local<v8::Value> local_err = v8impl::V8LocalValueFromJsValue(err);
+  v8impl::trigger_fatal_exception(env, local_err);
+
+  return napi_clear_last_error(env);
+}
+
 NAPI_NO_RETURN void napi_fatal_error(const char* location,
                                      size_t location_len,
                                      const char* message,
@@ -3457,10 +3474,9 @@ class Work : public node::AsyncResource {
       // report it as a fatal exception. (There is no JavaScript on the
       // callstack that can possibly handle it.)
       if (!env->last_exception.IsEmpty()) {
-        v8::TryCatch try_catch(env->isolate);
-        env->isolate->ThrowException(
-          v8::Local<v8::Value>::New(env->isolate, env->last_exception));
-        node::FatalException(env->isolate, try_catch);
+        v8::Local<v8::Value> local_err = v8::Local<v8::Value>::New(
+          env->isolate, env->last_exception);
+        v8impl::trigger_fatal_exception(env, local_err);
       }
     }
   }
diff --git a/src/node_api.h b/src/node_api.h
index c5b8a2a30cfe15..a2a73d5bcfd8f5 100644
--- a/src/node_api.h
+++ b/src/node_api.h
@@ -103,6 +103,8 @@ NAPI_EXTERN napi_status
 napi_get_last_error_info(napi_env env,
                          const napi_extended_error_info** result);
 
+NAPI_EXTERN napi_status napi_fatal_exception(napi_env env, napi_value err);
+
 NAPI_EXTERN NAPI_NO_RETURN void napi_fatal_error(const char* location,
                                                  size_t location_len,
                                                  const char* message,
diff --git a/src/node_internals.h b/src/node_internals.h
index de1b8adc87f4d3..bfb9bf296d7285 100644
--- a/src/node_internals.h
+++ b/src/node_internals.h
@@ -118,6 +118,11 @@ void GetSockOrPeerName(const v8::FunctionCallbackInfo<v8::Value>& args) {
   args.GetReturnValue().Set(err);
 }
 
+void FatalException(v8::Isolate* isolate,
+                    v8::Local<v8::Value> error,
+                    v8::Local<v8::Message> message);
+
+
 void SignalExit(int signo);
 #ifdef __POSIX__
 void RegisterSignalHandler(int signal,
diff --git a/test/addons-napi/test_async/test-uncaught.js b/test/addons-napi/test_async/test-uncaught.js
new file mode 100644
index 00000000000000..fdcb3203f54410
--- /dev/null
+++ b/test/addons-napi/test_async/test-uncaught.js
@@ -0,0 +1,18 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const test_async = require(`./build/${common.buildType}/test_async`);
+
+process.on('uncaughtException', common.mustCall(function(err) {
+  try {
+    throw new Error('should not fail');
+  } catch (err) {
+    assert.strictEqual(err.message, 'should not fail');
+  }
+  assert.strictEqual(err.message, 'uncaught');
+}));
+
+// Successful async execution and completion callback.
+test_async.Test(5, {}, common.mustCall(function() {
+  throw new Error('uncaught');
+}));
diff --git a/test/addons-napi/test_fatal_exception/binding.gyp b/test/addons-napi/test_fatal_exception/binding.gyp
new file mode 100644
index 00000000000000..f4dc0a71ea2817
--- /dev/null
+++ b/test/addons-napi/test_fatal_exception/binding.gyp
@@ -0,0 +1,8 @@
+{
+  "targets": [
+    {
+      "target_name": "test_fatal_exception",
+      "sources": [ "test_fatal_exception.c" ]
+    }
+  ]
+}
diff --git a/test/addons-napi/test_fatal_exception/test.js b/test/addons-napi/test_fatal_exception/test.js
new file mode 100644
index 00000000000000..f02b9bce1e8169
--- /dev/null
+++ b/test/addons-napi/test_fatal_exception/test.js
@@ -0,0 +1,11 @@
+'use strict';
+const common = require('../../common');
+const assert = require('assert');
+const test_fatal = require(`./build/${common.buildType}/test_fatal_exception`);
+
+process.on('uncaughtException', common.mustCall(function(err) {
+  assert.strictEqual(err.message, 'fatal error');
+}));
+
+const err = new Error('fatal error');
+test_fatal.Test(err);
diff --git a/test/addons-napi/test_fatal_exception/test_fatal_exception.c b/test/addons-napi/test_fatal_exception/test_fatal_exception.c
new file mode 100644
index 00000000000000..fd81c56d856db8
--- /dev/null
+++ b/test/addons-napi/test_fatal_exception/test_fatal_exception.c
@@ -0,0 +1,26 @@
+#include <node_api.h>
+#include "../common.h"
+
+napi_value Test(napi_env env, napi_callback_info info) {
+  napi_value err;
+  size_t argc = 1;
+
+  NAPI_CALL(env, napi_get_cb_info(env, info, &argc, &err, NULL, NULL));
+
+  NAPI_CALL(env, napi_fatal_exception(env, err));
+
+  return NULL;
+}
+
+napi_value Init(napi_env env, napi_value exports) {
+  napi_property_descriptor properties[] = {
+    DECLARE_NAPI_PROPERTY("Test", Test),
+  };
+
+  NAPI_CALL(env, napi_define_properties(
+      env, exports, sizeof(properties) / sizeof(*properties), properties));
+
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)

From 6b1201644c5d5cc624bbfad0abdad3f9a266f34b Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Mon, 19 Mar 2018 11:59:41 -0400
Subject: [PATCH 178/183] n-api: re-write test_make_callback

This re-writes the test in C by dropping std::vector<napi_value> in
favour of a C99 variable length array, and by dropping the anonymous
namespace in favour of static function declarations.

PR-URL: https://github.com/nodejs/node/pull/19448
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 .../{binding.cc => binding.c}                 | 21 +++++++++----------
 .../test_make_callback/binding.gyp            |  2 +-
 2 files changed, 11 insertions(+), 12 deletions(-)
 rename test/addons-napi/test_make_callback/{binding.cc => binding.c} (79%)

diff --git a/test/addons-napi/test_make_callback/binding.cc b/test/addons-napi/test_make_callback/binding.c
similarity index 79%
rename from test/addons-napi/test_make_callback/binding.cc
rename to test/addons-napi/test_make_callback/binding.c
index 18e558aecf8d33..f893319987cb89 100644
--- a/test/addons-napi/test_make_callback/binding.cc
+++ b/test/addons-napi/test_make_callback/binding.c
@@ -1,13 +1,13 @@
 #include <node_api.h>
 #include "../common.h"
-#include <vector>
 
-namespace {
+#define MAX_ARGUMENTS 10
 
+static
 napi_value MakeCallback(napi_env env, napi_callback_info info) {
-  const int kMaxArgs = 10;
-  size_t argc = kMaxArgs;
-  napi_value args[kMaxArgs];
+  size_t argc = MAX_ARGUMENTS;
+  size_t n;
+  napi_value args[MAX_ARGUMENTS];
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
 
   NAPI_ASSERT(env, argc > 0, "Wrong number of arguments");
@@ -15,9 +15,9 @@ napi_value MakeCallback(napi_env env, napi_callback_info info) {
   napi_value recv = args[0];
   napi_value func = args[1];
 
-  std::vector<napi_value> argv;
-  for (size_t n = 2; n < argc; n += 1) {
-    argv.push_back(args[n]);
+  napi_value argv[MAX_ARGUMENTS - 2];
+  for (n = 2; n < argc; n += 1) {
+    argv[n - 2] = args[n];
   }
 
   napi_valuetype func_type;
@@ -34,7 +34,7 @@ napi_value MakeCallback(napi_env env, napi_callback_info info) {
   napi_value result;
   if (func_type == napi_function) {
     NAPI_CALL(env, napi_make_callback(
-        env, context, recv, func, argv.size(), argv.data(), &result));
+        env, context, recv, func, argc - 2, argv, &result));
   } else {
     NAPI_ASSERT(env, false, "Unexpected argument type");
   }
@@ -44,6 +44,7 @@ napi_value MakeCallback(napi_env env, napi_callback_info info) {
   return result;
 }
 
+static
 napi_value Init(napi_env env, napi_value exports) {
   napi_value fn;
   NAPI_CALL(env, napi_create_function(
@@ -52,6 +53,4 @@ napi_value Init(napi_env env, napi_value exports) {
   return exports;
 }
 
-}  // namespace
-
 NAPI_MODULE(binding, Init)
diff --git a/test/addons-napi/test_make_callback/binding.gyp b/test/addons-napi/test_make_callback/binding.gyp
index 7ede63d94a0d77..23daf507916ff6 100644
--- a/test/addons-napi/test_make_callback/binding.gyp
+++ b/test/addons-napi/test_make_callback/binding.gyp
@@ -3,7 +3,7 @@
     {
       'target_name': 'binding',
       'defines': [ 'V8_DEPRECATION_WARNINGS=1' ],
-      'sources': [ 'binding.cc' ]
+      'sources': [ 'binding.c' ]
     }
   ]
 }

From 041c9a0a2bc68bf9bd23d8c9fb5eb0d00223b203 Mon Sep 17 00:00:00 2001
From: jiangq <jiangq.leaves+github@gmail.com>
Date: Fri, 23 Mar 2018 22:28:39 +0800
Subject: [PATCH 179/183] doc: Add a missing comma

PR-URL: https://github.com/nodejs/node/pull/19555
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
---
 doc/api/n-api.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index 4245c28fb046c0..e176cbdf1ef9cd 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -608,7 +608,7 @@ that has a loop which iterates through the elements in a large array:
 ```C
 for (int i = 0; i < 1000000; i++) {
   napi_value result;
-  napi_status status = napi_get_element(e object, i, &result);
+  napi_status status = napi_get_element(e, object, i, &result);
   if (status != napi_ok) {
     break;
   }
@@ -645,7 +645,7 @@ for (int i = 0; i < 1000000; i++) {
     break;
   }
   napi_value result;
-  status = napi_get_element(e object, i, &result);
+  status = napi_get_element(e, object, i, &result);
   if (status != napi_ok) {
     break;
   }

From 96fe46b91c82d27601e158f3d9acf63eebf2a5b6 Mon Sep 17 00:00:00 2001
From: Michael Dawson <mdawson@devrus.com>
Date: Tue, 20 Mar 2018 17:14:24 -0400
Subject: [PATCH 180/183] n-api: bump version of n-api supported

Bump the version due to additions to the api.

PR-URL: https://github.com/nodejs/node/pull/19497
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: Trivikram Kamat <trivikr.dev@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 src/node_version.h                    | 2 +-
 test/addons-napi/test_general/test.js | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/node_version.h b/src/node_version.h
index 843e5b524d533f..e71ed35478e3b7 100644
--- a/src/node_version.h
+++ b/src/node_version.h
@@ -62,6 +62,6 @@
 #define NODE_MODULE_VERSION 48 /* Node.js v6.0.0 */
 
 // the NAPI_VERSION provided by this version of the runtime
-#define NAPI_VERSION  2
+#define NAPI_VERSION  3
 
 #endif  // SRC_NODE_VERSION_H_
diff --git a/test/addons-napi/test_general/test.js b/test/addons-napi/test_general/test.js
index d43a1c69ba0c43..4faf508d5db145 100644
--- a/test/addons-napi/test_general/test.js
+++ b/test/addons-napi/test_general/test.js
@@ -32,9 +32,9 @@ assert.strictEqual(test_general.testGetPrototype(extendedObject),
 assert.notStrictEqual(test_general.testGetPrototype(baseObject),
                       test_general.testGetPrototype(extendedObject));
 
-// test version management funcitons
-// expected version is currently 1
-assert.strictEqual(test_general.testGetVersion(), 2);
+// test version management functions
+// expected version is currently 3
+assert.strictEqual(test_general.testGetVersion(), 3);
 
 const [ major, minor, patch, release ] = test_general.testGetNodeVersion();
 assert.strictEqual(process.version.split('-')[0],

From f4b0f7a49eae9ef18b33039471656d17068e4454 Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Thu, 22 Mar 2018 17:01:37 -0400
Subject: [PATCH 181/183] n-api: ensure in-module exceptions are propagated

Whenever we call into an addon, whether it is for a callback, for
module init, or for async work-related reasons, we should make sure
that

* the last error is cleared,
* the scopes before the call are the same as after, and
* if an exception was thrown and captured inside the module, then it is
  re-thrown after the call.

Therefore we should call into the module in a unified fashion. This
change introduces the macro NAPI_CALL_INTO_MODULE() which should be
used whenever invoking a callback provided by the module.

Fixes: https://github.com/nodejs/node/issues/19437
PR-URL: https://github.com/nodejs/node/pull/19537
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
---
 src/node_api.cc                               | 79 ++++++++++---------
 test/addons-napi/test_exception/test.js       | 30 ++++++-
 .../test_exception/test_exception.c           | 42 ++++++++--
 3 files changed, 108 insertions(+), 43 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index a52ecef27c4c27..e4638e4559af97 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -168,6 +168,24 @@ struct napi_env__ {
     (out) = v8::type::New((buffer), (byte_offset), (length));                  \
   } while (0)
 
+#define NAPI_CALL_INTO_MODULE(env, call, handle_exception)                   \
+  do {                                                                       \
+    int open_handle_scopes = (env)->open_handle_scopes;                      \
+    int open_callback_scopes = (env)->open_callback_scopes;                  \
+    napi_clear_last_error((env));                                            \
+    call;                                                                    \
+    CHECK_EQ((env)->open_handle_scopes, open_handle_scopes);                 \
+    CHECK_EQ((env)->open_callback_scopes, open_callback_scopes);             \
+    if (!(env)->last_exception.IsEmpty()) {                                  \
+      handle_exception(                                                      \
+          v8::Local<v8::Value>::New((env)->isolate, (env)->last_exception)); \
+      (env)->last_exception.Reset();                                         \
+    }                                                                        \
+  } while (0)
+
+#define NAPI_CALL_INTO_MODULE_THROW(env, call) \
+  NAPI_CALL_INTO_MODULE((env), call, (env)->isolate->ThrowException)
+
 namespace v8impl {
 
 // convert from n-api property attributes to v8::PropertyAttribute
@@ -349,10 +367,11 @@ class Finalizer {
   static void FinalizeBufferCallback(char* data, void* hint) {
     Finalizer* finalizer = static_cast<Finalizer*>(hint);
     if (finalizer->_finalize_callback != nullptr) {
-      finalizer->_finalize_callback(
-        finalizer->_env,
-        data,
-        finalizer->_finalize_hint);
+      NAPI_CALL_INTO_MODULE_THROW(finalizer->_env,
+        finalizer->_finalize_callback(
+          finalizer->_env,
+          data,
+          finalizer->_finalize_hint));
     }
 
     Delete(finalizer);
@@ -464,10 +483,11 @@ class Reference : private Finalizer {
     bool delete_self = reference->_delete_self;
 
     if (reference->_finalize_callback != nullptr) {
-      reference->_finalize_callback(
-          reference->_env,
-          reference->_finalize_data,
-          reference->_finalize_hint);
+      NAPI_CALL_INTO_MODULE_THROW(reference->_env,
+        reference->_finalize_callback(
+            reference->_env,
+            reference->_finalize_data,
+            reference->_finalize_hint));
     }
 
     if (delete_self) {
@@ -552,32 +572,17 @@ class CallbackWrapperBase : public CallbackWrapper {
     napi_callback cb = reinterpret_cast<napi_callback>(
         v8::Local<v8::External>::Cast(
             _cbdata->GetInternalField(kInternalFieldIndex))->Value());
-    v8::Isolate* isolate = _cbinfo.GetIsolate();
 
     napi_env env = static_cast<napi_env>(
         v8::Local<v8::External>::Cast(
             _cbdata->GetInternalField(kEnvIndex))->Value());
 
-    // Make sure any errors encountered last time we were in N-API are gone.
-    napi_clear_last_error(env);
-
-    int open_handle_scopes = env->open_handle_scopes;
-    int open_callback_scopes = env->open_callback_scopes;
-
-    napi_value result = cb(env, cbinfo_wrapper);
+    napi_value result;
+    NAPI_CALL_INTO_MODULE_THROW(env, result = cb(env, cbinfo_wrapper));
 
     if (result != nullptr) {
       this->SetReturnValue(result);
     }
-
-    CHECK_EQ(env->open_handle_scopes, open_handle_scopes);
-    CHECK_EQ(env->open_callback_scopes, open_callback_scopes);
-
-    if (!env->last_exception.IsEmpty()) {
-      isolate->ThrowException(
-          v8::Local<v8::Value>::New(isolate, env->last_exception));
-      env->last_exception.Reset();
-    }
   }
 
   const Info& _cbinfo;
@@ -885,8 +890,10 @@ void napi_module_register_cb(v8::Local<v8::Object> exports,
   // one is found.
   napi_env env = v8impl::GetEnv(context);
 
-  napi_value _exports =
-      mod->nm_register_func(env, v8impl::JsValueFromV8LocalValue(exports));
+  napi_value _exports;
+  NAPI_CALL_INTO_MODULE_THROW(env,
+      _exports = mod->nm_register_func(env,
+          v8impl::JsValueFromV8LocalValue(exports)));
 
   // If register function returned a non-null exports object different from
   // the exports object we passed it, set that as the "exports" property of
@@ -3465,19 +3472,17 @@ class Work : public node::AsyncResource {
       v8::HandleScope scope(env->isolate);
       CallbackScope callback_scope(work);
 
-      work->_complete(env, ConvertUVErrorCode(status), work->_data);
+      NAPI_CALL_INTO_MODULE(env,
+          work->_complete(env, ConvertUVErrorCode(status), work->_data),
+          [env] (v8::Local<v8::Value> local_err) {
+            // If there was an unhandled exception in the complete callback,
+            // report it as a fatal exception. (There is no JavaScript on the
+            // callstack that can possibly handle it.)
+            v8impl::trigger_fatal_exception(env, local_err);
+          });
 
       // Note: Don't access `work` after this point because it was
       // likely deleted by the complete callback.
-
-      // If there was an unhandled exception in the complete callback,
-      // report it as a fatal exception. (There is no JavaScript on the
-      // callstack that can possibly handle it.)
-      if (!env->last_exception.IsEmpty()) {
-        v8::Local<v8::Value> local_err = v8::Local<v8::Value>::New(
-          env->isolate, env->last_exception);
-        v8impl::trigger_fatal_exception(env, local_err);
-      }
     }
   }
 
diff --git a/test/addons-napi/test_exception/test.js b/test/addons-napi/test_exception/test.js
index 787b7d78b1c72b..b9311add6c92d7 100644
--- a/test/addons-napi/test_exception/test.js
+++ b/test/addons-napi/test_exception/test.js
@@ -1,10 +1,26 @@
 'use strict';
+// Flags: --expose-gc
 
 const common = require('../../common');
-const test_exception = require(`./build/${common.buildType}/test_exception`);
 const assert = require('assert');
 const theError = new Error('Some error');
 
+// The test module throws an error during Init, but in order for its exports to
+// not be lost, it attaches them to the error's "bindings" property. This way,
+// we can make sure that exceptions thrown during the module initialization
+// phase are propagated through require() into JavaScript.
+// https://github.com/nodejs/node/issues/19437
+const test_exception = (function() {
+  let resultingException;
+  try {
+    require(`./build/${common.buildType}/test_exception`);
+  } catch (anException) {
+    resultingException = anException;
+  }
+  assert.strictEqual(resultingException.message, 'Error during Init');
+  return resultingException.binding;
+})();
+
 {
   const throwTheError = () => { throw theError; };
 
@@ -50,3 +66,15 @@ const theError = new Error('Some error');
                      'Exception state did not remain clear as expected,' +
                      ` .wasPending() returned ${exception_pending}`);
 }
+
+// Make sure that exceptions that occur during finalization are propagated.
+function testFinalize(binding) {
+  let x = test_exception[binding]();
+  x = null;
+  assert.throws(() => { global.gc(); }, /Error during Finalize/);
+
+  // To assuage the linter's concerns.
+  (function() {})(x);
+}
+testFinalize('createExternal');
+testFinalize('createExternalBuffer');
diff --git a/test/addons-napi/test_exception/test_exception.c b/test/addons-napi/test_exception/test_exception.c
index 2ab01b653becfb..c83fd5ebcade19 100644
--- a/test/addons-napi/test_exception/test_exception.c
+++ b/test/addons-napi/test_exception/test_exception.c
@@ -3,7 +3,7 @@
 
 static bool exceptionWasPending = false;
 
-napi_value returnException(napi_env env, napi_callback_info info) {
+static napi_value returnException(napi_env env, napi_callback_info info) {
   size_t argc = 1;
   napi_value args[1];
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
@@ -22,7 +22,7 @@ napi_value returnException(napi_env env, napi_callback_info info) {
   return NULL;
 }
 
-napi_value allowException(napi_env env, napi_callback_info info) {
+static napi_value allowException(napi_env env, napi_callback_info info) {
   size_t argc = 1;
   napi_value args[1];
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, NULL, NULL));
@@ -38,23 +38,55 @@ napi_value allowException(napi_env env, napi_callback_info info) {
   return NULL;
 }
 
-napi_value wasPending(napi_env env, napi_callback_info info) {
+static napi_value wasPending(napi_env env, napi_callback_info info) {
   napi_value result;
   NAPI_CALL(env, napi_get_boolean(env, exceptionWasPending, &result));
 
   return result;
 }
 
-napi_value Init(napi_env env, napi_value exports) {
+static void finalizer(napi_env env, void *data, void *hint) {
+  NAPI_CALL_RETURN_VOID(env,
+      napi_throw_error(env, NULL, "Error during Finalize"));
+}
+
+static napi_value createExternal(napi_env env, napi_callback_info info) {
+  napi_value external;
+
+  NAPI_CALL(env,
+      napi_create_external(env, NULL, finalizer, NULL, &external));
+
+  return external;
+}
+
+static char buffer_data[12];
+
+static napi_value createExternalBuffer(napi_env env, napi_callback_info info) {
+  napi_value buffer;
+  NAPI_CALL(env, napi_create_external_buffer(env, sizeof(buffer_data),
+      buffer_data, finalizer, NULL, &buffer));
+  return buffer;
+}
+
+static napi_value Init(napi_env env, napi_value exports) {
   napi_property_descriptor descriptors[] = {
     DECLARE_NAPI_PROPERTY("returnException", returnException),
     DECLARE_NAPI_PROPERTY("allowException", allowException),
     DECLARE_NAPI_PROPERTY("wasPending", wasPending),
+    DECLARE_NAPI_PROPERTY("createExternal", createExternal),
+    DECLARE_NAPI_PROPERTY("createExternalBuffer", createExternalBuffer),
   };
-
   NAPI_CALL(env, napi_define_properties(
       env, exports, sizeof(descriptors) / sizeof(*descriptors), descriptors));
 
+  napi_value error, code, message;
+  NAPI_CALL(env, napi_create_string_utf8(env, "Error during Init",
+      NAPI_AUTO_LENGTH, &message));
+  NAPI_CALL(env, napi_create_string_utf8(env, "", NAPI_AUTO_LENGTH, &code));
+  NAPI_CALL(env, napi_create_error(env, code, message, &error));
+  NAPI_CALL(env, napi_set_named_property(env, error, "binding", exports));
+  NAPI_CALL(env, napi_throw(env, error));
+
   return exports;
 }
 

From dc4c8257b84b9558262af78b50219812bd0e601f Mon Sep 17 00:00:00 2001
From: Gabriel Schulhof <gabriel.schulhof@intel.com>
Date: Sat, 31 Mar 2018 21:37:17 -0400
Subject: [PATCH 182/183] n-api: back up env before finalize

Heed the comment to not use fields of a Reference after calling its
finalize callback, because such a call may destroy the Reference.

Fixes: https://github.com/nodejs/node/issues/19673
PR-URL: https://github.com/nodejs/node/pull/19718
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
---
 src/node_api.cc                                |  3 ++-
 test/addons-napi/8_passing_wrapped/binding.cc  | 15 ++++++++++++---
 test/addons-napi/8_passing_wrapped/myobject.cc | 12 +++++++++++-
 test/addons-napi/8_passing_wrapped/test.js     |  9 ++++++++-
 4 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/src/node_api.cc b/src/node_api.cc
index e4638e4559af97..a13398006b652d 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -481,9 +481,10 @@ class Reference : private Finalizer {
     // Check before calling the finalize callback, because the callback might
     // delete it.
     bool delete_self = reference->_delete_self;
+    napi_env env = reference->_env;
 
     if (reference->_finalize_callback != nullptr) {
-      NAPI_CALL_INTO_MODULE_THROW(reference->_env,
+      NAPI_CALL_INTO_MODULE_THROW(env,
         reference->_finalize_callback(
             reference->_env,
             reference->_finalize_data,
diff --git a/test/addons-napi/8_passing_wrapped/binding.cc b/test/addons-napi/8_passing_wrapped/binding.cc
index 86a6e4d739f03d..f38861d54d8dc2 100644
--- a/test/addons-napi/8_passing_wrapped/binding.cc
+++ b/test/addons-napi/8_passing_wrapped/binding.cc
@@ -1,7 +1,9 @@
 #include "myobject.h"
 #include "../common.h"
 
-napi_value CreateObject(napi_env env, napi_callback_info info) {
+extern size_t finalize_count;
+
+static napi_value CreateObject(napi_env env, napi_callback_info info) {
   size_t argc = 1;
   napi_value args[1];
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
@@ -12,7 +14,7 @@ napi_value CreateObject(napi_env env, napi_callback_info info) {
   return instance;
 }
 
-napi_value Add(napi_env env, napi_callback_info info) {
+static napi_value Add(napi_env env, napi_callback_info info) {
   size_t argc = 2;
   napi_value args[2];
   NAPI_CALL(env, napi_get_cb_info(env, info, &argc, args, nullptr, nullptr));
@@ -29,12 +31,19 @@ napi_value Add(napi_env env, napi_callback_info info) {
   return sum;
 }
 
-napi_value Init(napi_env env, napi_value exports) {
+static napi_value FinalizeCount(napi_env env, napi_callback_info info) {
+  napi_value return_value;
+  NAPI_CALL(env, napi_create_uint32(env, finalize_count, &return_value));
+  return return_value;
+}
+
+static napi_value Init(napi_env env, napi_value exports) {
   MyObject::Init(env);
 
   napi_property_descriptor desc[] = {
     DECLARE_NAPI_PROPERTY("createObject", CreateObject),
     DECLARE_NAPI_PROPERTY("add", Add),
+    DECLARE_NAPI_PROPERTY("finalizeCount", FinalizeCount),
   };
 
   NAPI_CALL(env,
diff --git a/test/addons-napi/8_passing_wrapped/myobject.cc b/test/addons-napi/8_passing_wrapped/myobject.cc
index 19cc7dd2a29493..0c9ca90f52f8f3 100644
--- a/test/addons-napi/8_passing_wrapped/myobject.cc
+++ b/test/addons-napi/8_passing_wrapped/myobject.cc
@@ -1,9 +1,14 @@
 #include "myobject.h"
 #include "../common.h"
 
+size_t finalize_count = 0;
+
 MyObject::MyObject() : env_(nullptr), wrapper_(nullptr) {}
 
-MyObject::~MyObject() { napi_delete_reference(env_, wrapper_); }
+MyObject::~MyObject() {
+  finalize_count++;
+  napi_delete_reference(env_, wrapper_);
+}
 
 void MyObject::Destructor(
   napi_env env, void* nativeObject, void* /*finalize_hint*/) {
@@ -45,6 +50,11 @@ napi_value MyObject::New(napi_env env, napi_callback_info info) {
   }
 
   obj->env_ = env;
+
+  // It is important that the below call to napi_wrap() be such that we request
+  // a reference to the wrapped object via the out-parameter, because this
+  // ensures that we test the code path that deals with a reference that is
+  // destroyed from its own finalizer.
   NAPI_CALL(env, napi_wrap(env,
                           _this,
                           obj,
diff --git a/test/addons-napi/8_passing_wrapped/test.js b/test/addons-napi/8_passing_wrapped/test.js
index 3d24fa5d9fdaa7..7793133f7750ba 100644
--- a/test/addons-napi/8_passing_wrapped/test.js
+++ b/test/addons-napi/8_passing_wrapped/test.js
@@ -1,9 +1,16 @@
 'use strict';
+// Flags: --expose-gc
+
 const common = require('../../common');
 const assert = require('assert');
 const addon = require(`./build/${common.buildType}/binding`);
 
-const obj1 = addon.createObject(10);
+let obj1 = addon.createObject(10);
 const obj2 = addon.createObject(20);
 const result = addon.add(obj1, obj2);
 assert.strictEqual(result, 30);
+
+// Make sure the native destructor gets called.
+obj1 = null;
+global.gc();
+assert.strictEqual(addon.finalizeCount(), 1);

From f498a625d0d0698242857a10d3616c2e75644283 Mon Sep 17 00:00:00 2001
From: Kyle Farnung <kfarnung@microsoft.com>
Date: Thu, 15 Mar 2018 17:22:30 -0700
Subject: [PATCH 183/183] n-api: add more `int64_t` tests

* Updated tests for `Number` and `int32_t`
* Added new tests for `int64_t`
* Updated N-API `int64_t` behavior to return zero for all non-finite
  numbers
* Clarified the documentation for these calls.

PR-URL: https://github.com/nodejs/node/pull/19402
Refs: https://github.com/nodejs/node-chakracore/pull/500
Reviewed-By: Michael Dawson <michael_dawson@ca.ibm.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 doc/api/n-api.md                     |  27 ++++--
 src/node_api.cc                      |  23 +++--
 test/addons-napi/test_number/test.js | 135 ++++++++++++++++++++-------
 3 files changed, 135 insertions(+), 50 deletions(-)

diff --git a/doc/api/n-api.md b/doc/api/n-api.md
index e176cbdf1ef9cd..38d7b22f558ec2 100644
--- a/doc/api/n-api.md
+++ b/doc/api/n-api.md
@@ -1806,13 +1806,17 @@ napi_status napi_get_value_int32(napi_env env,
 - `[out] result`: C int32 primitive equivalent of the given JavaScript Number.
 
 Returns `napi_ok` if the API succeeded. If a non-number `napi_value`
-is passed in `napi_number_expected .
+is passed in `napi_number_expected`.
 
 This API returns the C int32 primitive equivalent
-of the given JavaScript Number. If the number exceeds the range of the
-32 bit integer, then the result is truncated to the equivalent of the
-bottom 32 bits. This can result in a large positive number becoming
-a negative number if the value is > 2^31 -1.
+of the given JavaScript Number.
+
+If the number exceeds the range of the 32 bit integer, then the result is
+truncated to the equivalent of the bottom 32 bits. This can result in a large
+positive number becoming a negative number if the value is > 2^31 -1.
+
+Non-finite number values (NaN, positive infinity, or negative infinity) set the
+result to zero.
 
 #### napi_get_value_int64
 <!-- YAML
@@ -1831,8 +1835,17 @@ napi_status napi_get_value_int64(napi_env env,
 Returns `napi_ok` if the API succeeded. If a non-number `napi_value`
 is passed in it returns `napi_number_expected`.
 
-This API returns the C int64 primitive equivalent of the given
-JavaScript Number.
+This API returns the C int64 primitive equivalent of the given JavaScript
+Number.
+
+Number values outside the range of
+[`Number.MIN_SAFE_INTEGER`](https://tc39.github.io/ecma262/#sec-number.min_safe_integer)
+-(2^53 - 1) -
+[`Number.MAX_SAFE_INTEGER`](https://tc39.github.io/ecma262/#sec-number.max_safe_integer)
+(2^53 - 1) will lose precision.
+
+Non-finite number values (NaN, positive infinity, or negative infinity) set the
+result to zero.
 
 #### napi_get_value_string_latin1
 <!-- YAML
diff --git a/src/node_api.cc b/src/node_api.cc
index a13398006b652d..fbe468b5a30701 100644
--- a/src/node_api.cc
+++ b/src/node_api.cc
@@ -2193,15 +2193,24 @@ napi_status napi_get_value_int64(napi_env env,
 
   RETURN_STATUS_IF_FALSE(env, val->IsNumber(), napi_number_expected);
 
-  // v8::Value::IntegerValue() converts NaN to INT64_MIN, inconsistent with
-  // v8::Value::Int32Value() that converts NaN to 0. So special-case NaN here.
+  // v8::Value::IntegerValue() converts NaN, +Inf, and -Inf to INT64_MIN,
+  // inconsistent with v8::Value::Int32Value() which converts those values to 0.
+  // Special-case all non-finite values to match that behavior.
   double doubleValue = val.As<v8::Number>()->Value();
-  if (std::isnan(doubleValue)) {
-    *result = 0;
+  if (std::isfinite(doubleValue)) {
+    // v8::Value::IntegerValue() as shipped with v6.x returns inconsistent
+    // values outside of the int64_t range. We rectify that here.
+    if (doubleValue >= static_cast<double>(INT64_MAX)) {
+      *result = INT64_MAX;
+    } else if (doubleValue <= static_cast<double>((int64_t)-INT64_MAX - 1)) {
+      *result = -INT64_MAX - 1;
+    } else {
+      // Empty context: https://github.com/nodejs/node/issues/14379
+      v8::Local<v8::Context> context;
+      *result = val->IntegerValue(context).FromJust();
+    }
   } else {
-    // Empty context: https://github.com/nodejs/node/issues/14379
-    v8::Local<v8::Context> context;
-    *result = val->IntegerValue(context).FromJust();
+    *result = 0;
   }
 
   return napi_clear_last_error(env);
diff --git a/test/addons-napi/test_number/test.js b/test/addons-napi/test_number/test.js
index f9d6eb6a6f307a..3dbbb64932e502 100644
--- a/test/addons-napi/test_number/test.js
+++ b/test/addons-napi/test_number/test.js
@@ -5,50 +5,113 @@ const test_number = require(`./build/${common.buildType}/test_number`);
 
 
 // testing api calls for number
-assert.strictEqual(0, test_number.Test(0));
-assert.strictEqual(1, test_number.Test(1));
-assert.strictEqual(-1, test_number.Test(-1));
-assert.strictEqual(100, test_number.Test(100));
-assert.strictEqual(2121, test_number.Test(2121));
-assert.strictEqual(-1233, test_number.Test(-1233));
-assert.strictEqual(986583, test_number.Test(986583));
-assert.strictEqual(-976675, test_number.Test(-976675));
+function testNumber(num) {
+  assert.strictEqual(num, test_number.Test(num));
+}
 
-const num1 = 98765432213456789876546896323445679887645323232436587988766545658;
-assert.strictEqual(num1, test_number.Test(num1));
+testNumber(0);
+testNumber(-0);
+testNumber(1);
+testNumber(-1);
+testNumber(100);
+testNumber(2121);
+testNumber(-1233);
+testNumber(986583);
+testNumber(-976675);
 
-const num2 = -4350987086545760976737453646576078997096876957864353245245769809;
-assert.strictEqual(num2, test_number.Test(num2));
+testNumber(
+  98765432213456789876546896323445679887645323232436587988766545658);
+testNumber(
+  -4350987086545760976737453646576078997096876957864353245245769809);
+testNumber(Number.MIN_SAFE_INTEGER);
+testNumber(Number.MAX_SAFE_INTEGER);
+testNumber(Number.MAX_SAFE_INTEGER + 10);
 
-const num3 = Number.MAX_SAFE_INTEGER;
-assert.strictEqual(num3, test_number.Test(num3));
+testNumber(Number.MIN_VALUE);
+testNumber(Number.MAX_VALUE);
+testNumber(Number.MAX_VALUE + 10);
 
-const num4 = Number.MAX_SAFE_INTEGER + 10;
-assert.strictEqual(num4, test_number.Test(num4));
+testNumber(Number.POSITIVE_INFINITY);
+testNumber(Number.NEGATIVE_INFINITY);
+assert(Object.is(NaN, test_number.Test(NaN)));
 
-const num5 = Number.MAX_VALUE;
-assert.strictEqual(num5, test_number.Test(num5));
+// validate documented behavior when value is retrieved as 32-bit integer with
+// `napi_get_value_int32`
+function testInt32(input, expected = input) {
+  assert.strictEqual(expected, test_number.TestInt32Truncation(input));
+}
 
-const num6 = Number.MAX_VALUE + 10;
-assert.strictEqual(num6, test_number.Test(num6));
+// Test zero
+testInt32(0.0, 0);
+testInt32(-0.0, 0);
 
-const num7 = Number.POSITIVE_INFINITY;
-assert.strictEqual(num7, test_number.Test(num7));
+// Test min/max int32 range
+testInt32(-Math.pow(2, 31));
+testInt32(Math.pow(2, 31) - 1);
 
-const num8 = Number.NEGATIVE_INFINITY;
-assert.strictEqual(num8, test_number.Test(num8));
+// Test overflow scenarios
+testInt32(4294967297, 1);
+testInt32(4294967296, 0);
+testInt32(4294967295, -1);
+testInt32(4294967296 * 5 + 3, 3);
 
+// Test min/max safe integer range
+testInt32(Number.MIN_SAFE_INTEGER, 1);
+testInt32(Number.MAX_SAFE_INTEGER, -1);
 
-// validate documented behaviour when value is retrieved
-// as 32 bit integer with napi_get_value_int32
-assert.strictEqual(1, test_number.TestInt32Truncation(4294967297));
-assert.strictEqual(0, test_number.TestInt32Truncation(4294967296));
-assert.strictEqual(-1, test_number.TestInt32Truncation(4294967295));
-assert.strictEqual(3, test_number.TestInt32Truncation(4294967296 * 5 + 3));
+// Test within int64_t range (with precision loss)
+testInt32(-Math.pow(2, 63) + (Math.pow(2, 9) + 1), 1024);
+testInt32(Math.pow(2, 63) - (Math.pow(2, 9) + 1), -1024);
 
-// validate that the boundaries of safe integer can be passed through
-// successfully
-assert.strictEqual(Number.MAX_SAFE_INTEGER,
-                   test_number.TestInt64Truncation(Number.MAX_SAFE_INTEGER));
-assert.strictEqual(Number.MIN_SAFE_INTEGER,
-                   test_number.TestInt64Truncation(Number.MIN_SAFE_INTEGER));
+// Test min/max double value
+testInt32(-Number.MIN_VALUE, 0);
+testInt32(Number.MIN_VALUE, 0);
+testInt32(-Number.MAX_VALUE, 0);
+testInt32(Number.MAX_VALUE, 0);
+
+// Test outside int64_t range
+testInt32(-Math.pow(2, 63) + (Math.pow(2, 9)), 0);
+testInt32(Math.pow(2, 63) - (Math.pow(2, 9)), 0);
+
+// Test non-finite numbers
+testInt32(Number.POSITIVE_INFINITY, 0);
+testInt32(Number.NEGATIVE_INFINITY, 0);
+testInt32(Number.NaN, 0);
+
+// validate documented behavior when value is retrieved as 64-bit integer with
+// `napi_get_value_int64`
+function testInt64(input, expected = input) {
+  assert.strictEqual(expected, test_number.TestInt64Truncation(input));
+}
+
+// Both V8 and ChakraCore return a sentinel value of `0x8000000000000000` when
+// the conversion goes out of range, but V8 treats it as unsigned in some cases.
+const RANGEERROR_POSITIVE = Math.pow(2, 63);
+const RANGEERROR_NEGATIVE = -Math.pow(2, 63);
+
+// Test zero
+testInt64(0.0, 0);
+testInt64(-0.0, 0);
+
+// Test min/max safe integer range
+testInt64(Number.MIN_SAFE_INTEGER);
+testInt64(Number.MAX_SAFE_INTEGER);
+
+// Test within int64_t range (with precision loss)
+testInt64(-Math.pow(2, 63) + (Math.pow(2, 9) + 1));
+testInt64(Math.pow(2, 63) - (Math.pow(2, 9) + 1));
+
+// Test min/max double value
+testInt64(-Number.MIN_VALUE, 0);
+testInt64(Number.MIN_VALUE, 0);
+testInt64(-Number.MAX_VALUE, RANGEERROR_NEGATIVE);
+testInt64(Number.MAX_VALUE, RANGEERROR_POSITIVE);
+
+// Test outside int64_t range
+testInt64(-Math.pow(2, 63) + (Math.pow(2, 9)), RANGEERROR_NEGATIVE);
+testInt64(Math.pow(2, 63) - (Math.pow(2, 9)), RANGEERROR_POSITIVE);
+
+// Test non-finite numbers
+testInt64(Number.POSITIVE_INFINITY, 0);
+testInt64(Number.NEGATIVE_INFINITY, 0);
+testInt64(Number.NaN, 0);