Adding V8_WARN_UNUSED_RESULT for specified TODOs

src/wasm/wasm-js.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/api-natives.h"
 #include "src/api.h"
 #include "src/asmjs/asm-js.h"
 #include "src/asmjs/asm-typer.h"
 #include "src/asmjs/asm-wasm-builder.h"
 #include "src/assert-scope.h"
@@ skipping 171 matching lines @@
   ErrorThrower thrower(i_isolate, "WebAssembly.compile()");
 
   Local<Context> context = isolate->GetCurrentContext();
   v8::Local<v8::Promise::Resolver> resolver;
   if (!v8::Promise::Resolver::New(context).ToLocal(&resolver)) return;
   v8::ReturnValue<v8::Value> return_value = args.GetReturnValue();
   return_value.Set(resolver->GetPromise());
 
   auto bytes = GetFirstArgumentAsBytes(args, &thrower);
   if (!IsCompilationAllowed(i_isolate, &thrower, args[0], true)) {
-    resolver->Reject(context, Utils::ToLocal(thrower.Reify()));
+    auto maybe = resolver->Reject(context, Utils::ToLocal(thrower.Reify()));
+    CHECK(!maybe.IsNothing());
     return;
   }
   DCHECK(!thrower.error());
   i::Handle<i::JSPromise> promise = Utils::OpenHandle(*resolver->GetPromise());
   i::wasm::AsyncCompile(i_isolate, promise, bytes);
 }
 
 // WebAssembly.validate(bytes) -> bool
 void WebAssemblyValidate(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
@@ skipping 127 matching lines @@
 
   v8::Local<v8::Promise::Resolver> resolver;
   if (!v8::Promise::Resolver::New(context).ToLocal(&resolver)) return;
   v8::ReturnValue<v8::Value> return_value = args.GetReturnValue();
   return_value.Set(resolver->GetPromise());
 
   if (args.Length() < 1) {
     thrower.TypeError(
         "Argument 0 must be provided and must be either a buffer source or a "
         "WebAssembly.Module object");
-    resolver->Reject(context, Utils::ToLocal(thrower.Reify()));
+    auto maybe = resolver->Reject(context, Utils::ToLocal(thrower.Reify()));
+    CHECK(!maybe.IsNothing());
     return;
   }
 
   i::Handle<i::Object> first_arg = Utils::OpenHandle(*args[0]);
   if (!first_arg->IsJSObject()) {
     thrower.TypeError(
         "Argument 0 must be a buffer source or a WebAssembly.Module object");
-    resolver->Reject(context, Utils::ToLocal(thrower.Reify()));
+    auto maybe = resolver->Reject(context, Utils::ToLocal(thrower.Reify()));
+    CHECK(!maybe.IsNothing());
     return;
   }
 
   auto maybe_imports = GetSecondArgumentAsImports(args, &thrower);
   if (thrower.error()) {
-    resolver->Reject(context, Utils::ToLocal(thrower.Reify()));
+    auto maybe = resolver->Reject(context, Utils::ToLocal(thrower.Reify()));
+    CHECK(!maybe.IsNothing());
     return;
   }
   if (!IsInstantiationAllowed(i_isolate, &thrower, args[0], maybe_imports,
                               true)) {
-    resolver->Reject(context, Utils::ToLocal(thrower.Reify()));
+    auto maybe = resolver->Reject(context, Utils::ToLocal(thrower.Reify()));
+    CHECK(!maybe.IsNothing());
     return;
   }
   i::Handle<i::JSPromise> promise = Utils::OpenHandle(*resolver->GetPromise());
   if (HasBrand(first_arg, i::Handle<i::Symbol>(i_context->wasm_module_sym()))) {
     // WebAssembly.instantiate(module, imports) -> WebAssembly.Instance
     auto module_object = GetFirstArgumentAsModule(args, &thrower);
     i::wasm::AsyncInstantiate(i_isolate, promise,
                               module_object.ToHandleChecked(), maybe_imports);
   } else {
     // WebAssembly.instantiate(bytes, imports) -> {module, instance}
     auto bytes = GetFirstArgumentAsBytes(args, &thrower);
     if (thrower.error()) {
-      resolver->Reject(context, Utils::ToLocal(thrower.Reify()));
+      auto maybe = resolver->Reject(context, Utils::ToLocal(thrower.Reify()));
+      CHECK(!maybe.IsNothing());
       return;
     }
     i::wasm::AsyncCompileAndInstantiate(i_isolate, promise, bytes,
                                         maybe_imports);
   }
 }
 
 bool GetIntegerProperty(v8::Isolate* isolate, ErrorThrower* thrower,
                         Local<Context> context, Local<v8::Object> object,
                         Local<String> property, int* result,
@@ skipping 535 matching lines @@
   i::Handle<i::Symbol> symbol(isolate->context()->wasm_memory_sym(), isolate);
   return HasBrand(value, symbol);
 }
 
 bool WasmJs::IsWasmTableObject(Isolate* isolate, Handle<Object> value) {
   i::Handle<i::Symbol> symbol(isolate->context()->wasm_table_sym(), isolate);
   return HasBrand(value, symbol);
 }
 }  // namespace internal
 }  // namespace v8