convert compile functions to use maybe

include/v8.h

 // 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.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 421 matching lines @@
   V8_INLINE MaybeLocal(Local<S> that)
       : val_(reinterpret_cast<T*>(*that)) {
     TYPE_CHECK(T, S);
   }
 
   V8_INLINE bool IsEmpty() const { return val_ == nullptr; }
 
   template <class S>
   V8_WARN_UNUSED_RESULT V8_INLINE bool ToLocal(Local<S>* out) const {
     out->val_ = IsEmpty() ? nullptr : this->val_;
-    return IsEmpty();
+    return !IsEmpty();
   }
 
   V8_INLINE Local<T> ToLocalChecked() {
     // TODO(dcarney): add DCHECK.
     return Local<T>(val_);
   }
 
   template <class S>
   V8_INLINE Local<S> FromMaybe(Local<S> default_value) const {
     return IsEmpty() ? default_value : Local<S>(val_);
@@ skipping 606 matching lines @@
 
 /**
  * A compiled JavaScript script, tied to a Context which was active when the
  * script was compiled.
  */
 class V8_EXPORT Script {
  public:
   /**
    * A shorthand for ScriptCompiler::Compile().
    */
+  // TODO(dcarney): deprecate.
   static Local<Script> Compile(Handle<String> source,
-                               ScriptOrigin* origin = NULL);
+                               ScriptOrigin* origin = nullptr);
+  static MaybeLocal<Script> Compile(Local<Context> context,
+                                    Handle<String> source,
+                                    ScriptOrigin* origin = nullptr);
 
-  // To be decprecated, use the Compile above.
+  // TODO(dcarney): deprecate.
   static Local<Script> Compile(Handle<String> source,
                                Handle<String> file_name);
 
   /**
    * Runs the script returning the resulting value. It will be run in the
    * context in which it was created (ScriptCompiler::CompileBound or
    * UnboundScript::BindToCurrentContext()).
    */
   Local<Value> Run();
 
@@ skipping 175 matching lines @@
    * consumed later to speed up compilation of identical source scripts.
    *
    * Note that when producing cached data, the source must point to NULL for
    * cached data. When consuming cached data, the cached data must have been
    * produced by the same version of V8.
    *
    * \param source Script source code.
    * \return Compiled script object (context independent; for running it must be
    *   bound to a context).
    */
+  // TODO(dcarney): deprecate
   static Local<UnboundScript> CompileUnbound(
       Isolate* isolate, Source* source,
       CompileOptions options = kNoCompileOptions);
+  static MaybeLocal<UnboundScript> CompileUnboundScript(
+      Isolate* isolate, Source* source,
+      CompileOptions options = kNoCompileOptions);
 
   /**
    * Compiles the specified script (bound to current context).
    *
    * \param source Script source code.
    * \param pre_data Pre-parsing data, as obtained by ScriptData::PreCompile()
    *   using pre_data speeds compilation if it's done multiple times.
    *   Owned by caller, no references are kept when this function returns.
    * \return Compiled script object, bound to the context that was active
    *   when this function was called. When run it will always use this
    *   context.
    */
+  // TODO(dcarney): deprecate
   static Local<Script> Compile(
       Isolate* isolate, Source* source,
       CompileOptions options = kNoCompileOptions);
+  static MaybeLocal<Script> Compile(Local<Context> context, Source* source,
+                                    CompileOptions options = kNoCompileOptions);
 
   /**
    * Returns a task which streams script data into V8, or NULL if the script
    * cannot be streamed. The user is responsible for running the task on a
    * background thread and deleting it. When ran, the task starts parsing the
    * script, and it will request data from the StreamedSource as needed. When
    * ScriptStreamingTask::Run exits, all data has been streamed and the script
    * can be compiled (see Compile below).
    *
    * This API allows to start the streaming with as little data as possible, and
    * the remaining data (for example, the ScriptOrigin) is passed to Compile.
    */
   static ScriptStreamingTask* StartStreamingScript(
       Isolate* isolate, StreamedSource* source,
       CompileOptions options = kNoCompileOptions);
 
   /**
    * Compiles a streamed script (bound to current context).
    *
    * This can only be called after the streaming has finished
    * (ScriptStreamingTask has been run). V8 doesn't construct the source string
    * during streaming, so the embedder needs to pass the full source here.
    */
+  // TODO(dcarney): deprecate
   static Local<Script> Compile(Isolate* isolate, StreamedSource* source,
                                Handle<String> full_source_string,
                                const ScriptOrigin& origin);
+  static MaybeLocal<Script> Compile(Local<Context> context,
+                                    StreamedSource* source,
+                                    Handle<String> full_source_string,
+                                    const ScriptOrigin& origin);
 
   /**
    * Return a version tag for CachedData for the current V8 version & flags.
    *
    * This value is meant only for determining whether a previously generated
    * CachedData instance is still valid; the tag has no other meaing.
    *
    * Background: The data carried by CachedData may depend on the exact
    *   V8 version number or currently compiler flags. This means when
    *   persisting CachedData, the embedder must take care to not pass in
    *   data from another V8 version, or the same version with different
    *   features enabled.
    *
    *   The easiest way to do so is to clear the embedder's cache on any
    *   such change.
    *
    *   Alternatively, this tag can be stored alongside the cached data and
    *   compared when it is being used.
    */
   static uint32_t CachedDataVersionTag();
 
   /**
    * Compile an ES6 module.
    *
    * This is an experimental feature.
    *
    * TODO(adamk): Script is likely the wrong return value for this;
    * should return some new Module type.
    */
+  // TODO(dcarney): deprecate.
   static Local<Script> CompileModule(
       Isolate* isolate, Source* source,
       CompileOptions options = kNoCompileOptions);
+  static MaybeLocal<Script> CompileModule(
+      Local<Context> context, Source* source,
+      CompileOptions options = kNoCompileOptions);
 
   /**
    * Compile a function for a given context. This is equivalent to running
    *
    * with (obj) {
    *   return function(args) { ... }
    * }
    *
    * It is possible to specify multiple context extensions (obj in the above
    * example).
    */
+  // TODO(dcarney): deprecate.
   static Local<Function> CompileFunctionInContext(
       Isolate* isolate, Source* source, Local<Context> context,
       size_t arguments_count, Local<String> arguments[],
       size_t context_extension_count, Local<Object> context_extensions[]);
+  static MaybeLocal<Function> CompileFunctionInContext(
+      Local<Context> context, Source* source, size_t arguments_count,
+      Local<String> arguments[], size_t context_extension_count,
+      Local<Object> context_extensions[]);
 
  private:
-  static Local<UnboundScript> CompileUnboundInternal(Isolate* isolate,
-                                                     Source* source,
-                                                     CompileOptions options,
-                                                     bool is_module);
+  static MaybeLocal<UnboundScript> CompileUnboundInternal(
+      Isolate* isolate, Source* source, CompileOptions options, bool is_module);
 };
 
 
 /**
  * An error message.
  */
 class V8_EXPORT Message {
  public:
   Local<String> Get() const;
   Local<String> GetSourceLine() const;
@@ skipping 6347 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_