ensure maybe results are checked in v8.h

src/api.cc

 // Copyright 2012 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.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 1657 matching lines @@
 
   i::ScriptData* script_data = NULL;
   if (options == kConsumeParserCache || options == kConsumeCodeCache) {
     DCHECK(source->cached_data);
     // ScriptData takes care of pointer-aligning the data.
     script_data = new i::ScriptData(source->cached_data->data,
                                     source->cached_data->length);
   }
 
   i::Handle<i::String> str = Utils::OpenHandle(*(source->source_string));
-  i::SharedFunctionInfo* raw_result = NULL;
-  { i::HandleScope scope(isolate);
+  i::Handle<i::SharedFunctionInfo> result;
+  {
     i::HistogramTimerScope total(isolate->counters()->compile_script(), true);
     i::Handle<i::Object> name_obj;
     i::Handle<i::Object> source_map_url;
     int line_offset = 0;
     int column_offset = 0;
     bool is_embedder_debug_script = false;
     bool is_shared_cross_origin = false;
     if (!source->resource_name.IsEmpty()) {
       name_obj = Utils::OpenHandle(*(source->resource_name));
     }
     if (!source->resource_line_offset.IsEmpty()) {
       line_offset = static_cast<int>(source->resource_line_offset->Value());
     }
     if (!source->resource_column_offset.IsEmpty()) {
       column_offset =
           static_cast<int>(source->resource_column_offset->Value());
     }
     if (!source->resource_is_shared_cross_origin.IsEmpty()) {
       is_shared_cross_origin =
           source->resource_is_shared_cross_origin->IsTrue();
     }
     if (!source->resource_is_embedder_debug_script.IsEmpty()) {
       is_embedder_debug_script =
           source->resource_is_embedder_debug_script->IsTrue();
     }
     if (!source->source_map_url.IsEmpty()) {
       source_map_url = Utils::OpenHandle(*(source->source_map_url));
     }
-    i::Handle<i::SharedFunctionInfo> result = i::Compiler::CompileScript(
+    result = i::Compiler::CompileScript(
         str, name_obj, line_offset, column_offset, is_embedder_debug_script,
         is_shared_cross_origin, source_map_url, isolate->native_context(), NULL,
         &script_data, options, i::NOT_NATIVES_CODE, is_module);
     has_pending_exception = result.is_null();
     if (has_pending_exception && script_data != NULL) {
       // This case won't happen during normal operation; we have compiled
       // successfully and produced cached data, and but the second compilation
       // of the same source code fails.
       delete script_data;
       script_data = NULL;
     }
     RETURN_ON_FAILED_EXECUTION(UnboundScript);
-    raw_result = *result;
 
     if ((options == kProduceParserCache || options == kProduceCodeCache) &&
         script_data != NULL) {
       // script_data now contains the data that was generated. source will
       // take the ownership.
       source->cached_data = new CachedData(
           script_data->data(), script_data->length(), CachedData::BufferOwned);
       script_data->ReleaseDataOwnership();
     } else if (options == kConsumeParserCache || options == kConsumeCodeCache) {
       source->cached_data->rejected = script_data->rejected();
     }
     delete script_data;
   }
-  i::Handle<i::SharedFunctionInfo> result(raw_result, isolate);
   RETURN_ESCAPED(ToApiHandle<UnboundScript>(result));
 }
 
 
 MaybeLocal<UnboundScript> ScriptCompiler::CompileUnboundScript(
     Isolate* v8_isolate, Source* source, CompileOptions options) {
   return CompileUnboundInternal(v8_isolate, source, options, false);
 }
 
 
@@ skipping 178 matching lines @@
                                       i::FLAG_stack_size, isolate);
 }
 
 
 MaybeLocal<Script> ScriptCompiler::Compile(Local<Context> context,
                                            StreamedSource* v8_source,
                                            Handle<String> full_source_string,
                                            const ScriptOrigin& origin) {
   PREPARE_FOR_EXECUTION(context, "v8::ScriptCompiler::Compile()", Script);
   i::StreamedSource* source = v8_source->impl();
-  i::SharedFunctionInfo* raw_result = nullptr;
-  {
-    i::HandleScope scope(isolate);
-    i::Handle<i::String> str = Utils::OpenHandle(*(full_source_string));
-    i::Handle<i::Script> script = isolate->factory()->NewScript(str);
-    if (!origin.ResourceName().IsEmpty()) {
-      script->set_name(*Utils::OpenHandle(*(origin.ResourceName())));
-    }
-    if (!origin.ResourceLineOffset().IsEmpty()) {
-      script->set_line_offset(i::Smi::FromInt(
-          static_cast<int>(origin.ResourceLineOffset()->Value())));
-    }
-    if (!origin.ResourceColumnOffset().IsEmpty()) {
-      script->set_column_offset(i::Smi::FromInt(
-          static_cast<int>(origin.ResourceColumnOffset()->Value())));
-    }
-    if (!origin.ResourceIsSharedCrossOrigin().IsEmpty()) {
-      script->set_is_shared_cross_origin(
-          origin.ResourceIsSharedCrossOrigin()->IsTrue());
-    }
-    if (!origin.ResourceIsEmbedderDebugScript().IsEmpty()) {
-      script->set_is_embedder_debug_script(
-          origin.ResourceIsEmbedderDebugScript()->IsTrue());
-    }
-    if (!origin.SourceMapUrl().IsEmpty()) {
-      script->set_source_mapping_url(
-          *Utils::OpenHandle(*(origin.SourceMapUrl())));
-    }
-
-    source->info->set_script(script);
-    source->info->set_context(isolate->native_context());
-
-    // Do the parsing tasks which need to be done on the main thread. This will
-    // also handle parse errors.
-    source->parser->Internalize(isolate, script,
-                                source->info->function() == nullptr);
-    source->parser->HandleSourceURLComments(isolate, script);
-
-    i::Handle<i::SharedFunctionInfo> result;
-    if (source->info->function() != nullptr) {
-      // Parsing has succeeded.
-      result = i::Compiler::CompileStreamedScript(script, source->info.get(),
-                                                  str->length());
-    }
-    has_pending_exception = result.is_null();
-    if (has_pending_exception) isolate->ReportPendingMessages();
-    RETURN_ON_FAILED_EXECUTION(Script);
-
-    source->info->clear_script();  // because script goes out of scope.
-    raw_result = *result;          // TODO(titzer): use CloseAndEscape?
+  i::Handle<i::String> str = Utils::OpenHandle(*(full_source_string));
+  i::Handle<i::Script> script = isolate->factory()->NewScript(str);
+  if (!origin.ResourceName().IsEmpty()) {
+    script->set_name(*Utils::OpenHandle(*(origin.ResourceName())));
+  }
+  if (!origin.ResourceLineOffset().IsEmpty()) {
+    script->set_line_offset(i::Smi::FromInt(
+        static_cast<int>(origin.ResourceLineOffset()->Value())));
+  }
+  if (!origin.ResourceColumnOffset().IsEmpty()) {
+    script->set_column_offset(i::Smi::FromInt(
+        static_cast<int>(origin.ResourceColumnOffset()->Value())));
+  }
+  if (!origin.ResourceIsSharedCrossOrigin().IsEmpty()) {
+    script->set_is_shared_cross_origin(
+        origin.ResourceIsSharedCrossOrigin()->IsTrue());
+  }
+  if (!origin.ResourceIsEmbedderDebugScript().IsEmpty()) {
+    script->set_is_embedder_debug_script(
+        origin.ResourceIsEmbedderDebugScript()->IsTrue());
+  }
+  if (!origin.SourceMapUrl().IsEmpty()) {
+    script->set_source_mapping_url(
+        *Utils::OpenHandle(*(origin.SourceMapUrl())));
   }
 
-  i::Handle<i::SharedFunctionInfo> result(raw_result, isolate);
+  source->info->set_script(script);
+  source->info->set_context(isolate->native_context());
+
+  // Do the parsing tasks which need to be done on the main thread. This will
+  // also handle parse errors.
+  source->parser->Internalize(isolate, script,
+                              source->info->function() == nullptr);
+  source->parser->HandleSourceURLComments(isolate, script);
+
+  i::Handle<i::SharedFunctionInfo> result;
+  if (source->info->function() != nullptr) {
+    // Parsing has succeeded.
+    result = i::Compiler::CompileStreamedScript(script, source->info.get(),
+                                                str->length());
+  }
+  has_pending_exception = result.is_null();
+  if (has_pending_exception) isolate->ReportPendingMessages();
+  RETURN_ON_FAILED_EXECUTION(Script);
+
+  source->info->clear_script();  // because script goes out of scope.
+
   Local<UnboundScript> generic = ToApiHandle<UnboundScript>(result);
   if (generic.IsEmpty()) return Local<Script>();
   Local<Script> bound = generic->BindToCurrentContext();
   if (bound.IsEmpty()) return Local<Script>();
   RETURN_ESCAPED(bound);
 }
 
 
 Local<Script> ScriptCompiler::Compile(Isolate* v8_isolate,
                                       StreamedSource* v8_source,
@@ skipping 4251 matching lines @@
       isolate->factory()->undefined_value(),
       arraysize(argv), argv,
       false).is_null();
   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
   return Just(true);
 }
 
 
 void Promise::Resolver::Resolve(Handle<Value> value) {
   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
-  Resolve(context, value);
+  USE(Resolve(context, value));
 }
 
 
 Maybe<bool> Promise::Resolver::Reject(Local<Context> context,
                                       Handle<Value> value) {
   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "Promise::Resolver::Resolve", bool);
   auto self = Utils::OpenHandle(this);
   i::Handle<i::Object> argv[] = {self, Utils::OpenHandle(*value)};
   has_pending_exception = i::Execution::Call(
       isolate,
       isolate->promise_reject(),
       isolate->factory()->undefined_value(),
       arraysize(argv), argv,
       false).is_null();
   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
   return Just(true);
 }
 
 
 void Promise::Resolver::Reject(Handle<Value> value) {
   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
-  Reject(context, value);
+  USE(Reject(context, value));
 }
 
 
 MaybeLocal<Promise> Promise::Chain(Local<Context> context,
                                    Handle<Function> handler) {
   PREPARE_FOR_EXECUTION(context, "Promise::Chain", Promise);
   auto self = Utils::OpenHandle(this);
   i::Handle<i::Object> argv[] = {Utils::OpenHandle(*handler)};
   i::Handle<i::Object> result;
   has_pending_exception =
@@ skipping 1771 matching lines @@
   Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate());
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 } }  // namespace v8::internal