ensure maybe results are checked in v8.h

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 1100 matching lines @@
  */
 class V8_EXPORT Script {
  public:
   /**
    * A shorthand for ScriptCompiler::Compile().
    */
   static V8_DEPRECATE_SOON(
       "Use maybe version",
       Local<Script> Compile(Handle<String> source,
                             ScriptOrigin* origin = nullptr));
-  static MaybeLocal<Script> Compile(Local<Context> context,
-                                    Handle<String> source,
-                                    ScriptOrigin* origin = nullptr);
+  static V8_WARN_UNUSED_RESULT MaybeLocal<Script> Compile(
+      Local<Context> context, Handle<String> source,
+      ScriptOrigin* origin = nullptr);
 
   static Local<Script> V8_DEPRECATE_SOON("Use maybe version",
                                          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()).
    */
   V8_DEPRECATE_SOON("Use maybe version", Local<Value> Run());
-  MaybeLocal<Value> Run(Local<Context> context);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Value> Run(Local<Context> context);
 
   /**
    * Returns the corresponding context-unbound script.
    */
   Local<UnboundScript> GetUnboundScript();
 
   V8_DEPRECATED("Use GetUnboundScript()->GetId()",
                 int GetId()) {
     return GetUnboundScript()->GetId();
   }
@@ skipping 171 matching lines @@
    * 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).
    */
   static V8_DEPRECATE_SOON("Use maybe version",
                            Local<UnboundScript> CompileUnbound(
                                Isolate* isolate, Source* source,
                                CompileOptions options = kNoCompileOptions));
-  static MaybeLocal<UnboundScript> CompileUnboundScript(
+  static V8_WARN_UNUSED_RESULT 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.
    */
   static V8_DEPRECATE_SOON(
       "Use maybe version",
       Local<Script> Compile(Isolate* isolate, Source* source,
                             CompileOptions options = kNoCompileOptions));
-  static MaybeLocal<Script> Compile(Local<Context> context, Source* source,
-                                    CompileOptions options = kNoCompileOptions);
+  static V8_WARN_UNUSED_RESULT 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.
    */
   static V8_DEPRECATE_SOON(
       "Use maybe version",
       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);
+  static V8_WARN_UNUSED_RESULT 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
@@ skipping 13 matching lines @@
    *
    * This is an experimental feature.
    *
    * TODO(adamk): Script is likely the wrong return value for this;
    * should return some new Module type.
    */
   static V8_DEPRECATE_SOON(
       "Use maybe version",
       Local<Script> CompileModule(Isolate* isolate, Source* source,
                                   CompileOptions options = kNoCompileOptions));
-  static MaybeLocal<Script> CompileModule(
+  static V8_WARN_UNUSED_RESULT 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).
    */
   static V8_DEPRECATE_SOON("Use maybe version",
                            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(
+  static V8_WARN_UNUSED_RESULT 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 MaybeLocal<UnboundScript> CompileUnboundInternal(
+  static V8_WARN_UNUSED_RESULT MaybeLocal<UnboundScript> CompileUnboundInternal(
       Isolate* isolate, Source* source, CompileOptions options, bool is_module);
 };
 
 
 /**
  * An error message.
  */
 class V8_EXPORT Message {
  public:
   Local<String> Get() const;
 
   V8_DEPRECATE_SOON("Use maybe version", Local<String> GetSourceLine()) const;
-  MaybeLocal<String> GetSourceLine(Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT MaybeLocal<String> GetSourceLine(
+      Local<Context> context) const;
 
   /**
    * Returns the origin for the script from where the function causing the
    * error originates.
    */
   ScriptOrigin GetScriptOrigin() const;
 
   /**
    * Returns the resource name for the script from where the function causing
    * the error originates.
    */
   Handle<Value> GetScriptResourceName() const;
 
   /**
    * Exception stack trace. By default stack traces are not captured for
    * uncaught exceptions. SetCaptureStackTraceForUncaughtExceptions allows
    * to change this option.
    */
   Handle<StackTrace> GetStackTrace() const;
 
   /**
    * Returns the number, 1-based, of the line where the error occurred.
    */
   V8_DEPRECATE_SOON("Use maybe version", int GetLineNumber()) const;
-  Maybe<int> GetLineNumber(Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT Maybe<int> GetLineNumber(Local<Context> context) const;
 
   /**
    * Returns the index within the script of the first character where
    * the error occurred.
    */
   int GetStartPosition() const;
 
   /**
    * Returns the index within the script of the last character where
    * the error occurred.
    */
   int GetEndPosition() const;
 
   /**
    * Returns the index within the line of the first character where
    * the error occurred.
    */
   V8_DEPRECATE_SOON("Use maybe version", int GetStartColumn()) const;
-  Maybe<int> GetStartColumn(Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT Maybe<int> GetStartColumn(Local<Context> context) const;
 
   /**
    * Returns the index within the line of the last character where
    * the error occurred.
    */
   V8_DEPRECATE_SOON("Use maybe version", int GetEndColumn()) const;
-  Maybe<int> GetEndColumn(Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT Maybe<int> GetEndColumn(Local<Context> context) const;
 
   /**
    * Passes on the value set by the embedder when it fed the script from which
    * this Message was generated to V8.
    */
   bool IsSharedCrossOrigin() const;
 
   // TODO(1245381): Print to a string instead of on a FILE.
   static void PrintCurrentStackTrace(Isolate* isolate, FILE* out);
 
@@ skipping 148 matching lines @@
  public:
   /**
    * Tries to parse the string |json_string| and returns it as value if
    * successful.
    *
    * \param json_string The string to parse.
    * \return The corresponding value if successfully parsed.
    */
   static V8_DEPRECATE_SOON("Use maybe version",
                            Local<Value> Parse(Local<String> json_string));
-  static MaybeLocal<Value> Parse(Isolate* isolate, Local<String> json_string);
+  static V8_WARN_UNUSED_RESULT MaybeLocal<Value> Parse(
+      Isolate* isolate, Local<String> json_string);
 };
 
 
 /**
  * A map whose keys are referenced weakly. It is similar to JavaScript WeakMap
  * but can be created without entering a v8::Context and hence shouldn't
  * escape to JavaScript.
  */
 class V8_EXPORT NativeWeakMap : public Data {
  public:
@@ skipping 259 matching lines @@
    * This is an experimental feature.
    */
   bool IsFloat64Array() const;
 
   /**
    * Returns true if this value is a DataView.
    * This is an experimental feature.
    */
   bool IsDataView() const;
 
-  MaybeLocal<Boolean> ToBoolean(Local<Context> context) const;
-  MaybeLocal<Number> ToNumber(Local<Context> context) const;
-  MaybeLocal<String> ToString(Local<Context> context) const;
-  MaybeLocal<String> ToDetailString(Local<Context> context) const;
-  MaybeLocal<Object> ToObject(Local<Context> context) const;
-  MaybeLocal<Integer> ToInteger(Local<Context> context) const;
-  MaybeLocal<Uint32> ToUint32(Local<Context> context) const;
-  MaybeLocal<Int32> ToInt32(Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT MaybeLocal<Boolean> ToBoolean(
+      Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT MaybeLocal<Number> ToNumber(
+      Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT MaybeLocal<String> ToString(
+      Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT MaybeLocal<String> ToDetailString(
+      Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT MaybeLocal<Object> ToObject(
+      Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT MaybeLocal<Integer> ToInteger(
+      Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT MaybeLocal<Uint32> ToUint32(
+      Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT MaybeLocal<Int32> ToInt32(Local<Context> context) const;
 
   V8_DEPRECATE_SOON("Use maybe version",
                     Local<Boolean> ToBoolean(Isolate* isolate)) const;
   V8_DEPRECATE_SOON("Use maybe version",
                     Local<Number> ToNumber(Isolate* isolate)) const;
   V8_DEPRECATE_SOON("Use maybe version",
                     Local<String> ToString(Isolate* isolate)) const;
   V8_DEPRECATE_SOON("Use maybe version",
                     Local<String> ToDetailString(Isolate* isolate)) const;
   V8_DEPRECATE_SOON("Use maybe version",
@@ skipping 15 matching lines @@
   inline V8_DEPRECATE_SOON("Use maybe version",
                            Local<Integer> ToInteger()) const;
   inline V8_DEPRECATE_SOON("Use maybe version", Local<Uint32> ToUint32()) const;
   inline V8_DEPRECATE_SOON("Use maybe version", Local<Int32> ToInt32()) const;
 
   /**
    * Attempts to convert a string to an array index.
    * Returns an empty handle if the conversion fails.
    */
   V8_DEPRECATE_SOON("Use maybe version", Local<Uint32> ToArrayIndex()) const;
-  MaybeLocal<Uint32> ToArrayIndex(Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT MaybeLocal<Uint32> ToArrayIndex(
+      Local<Context> context) const;
 
-  Maybe<bool> BooleanValue(Local<Context> context) const;
-  Maybe<double> NumberValue(Local<Context> context) const;
-  Maybe<int64_t> IntegerValue(Local<Context> context) const;
-  Maybe<uint32_t> Uint32Value(Local<Context> context) const;
-  Maybe<int32_t> Int32Value(Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT Maybe<bool> BooleanValue(Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT Maybe<double> NumberValue(Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT Maybe<int64_t> IntegerValue(
+      Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT Maybe<uint32_t> Uint32Value(
+      Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT Maybe<int32_t> Int32Value(Local<Context> context) const;
 
   V8_DEPRECATE_SOON("Use maybe version", bool BooleanValue()) const;
   V8_DEPRECATE_SOON("Use maybe version", double NumberValue()) const;
   V8_DEPRECATE_SOON("Use maybe version", int64_t IntegerValue()) const;
   V8_DEPRECATE_SOON("Use maybe version", uint32_t Uint32Value()) const;
   V8_DEPRECATE_SOON("Use maybe version", int32_t Int32Value()) const;
 
   /** JS == */
   V8_DEPRECATE_SOON("Use maybe version", bool Equals(Handle<Value> that)) const;
-  Maybe<bool> Equals(Local<Context> context, Handle<Value> that) const;
+  V8_WARN_UNUSED_RESULT Maybe<bool> Equals(Local<Context> context,
+                                           Handle<Value> that) const;
   bool StrictEquals(Handle<Value> that) const;
   bool SameValue(Handle<Value> that) const;
 
   template <class T> V8_INLINE static Value* Cast(T* value);
 
  private:
   V8_INLINE bool QuickIsUndefined() const;
   V8_INLINE bool QuickIsNull() const;
   V8_INLINE bool QuickIsString() const;
   bool FullIsUndefined() const;
@@ skipping 256 matching lines @@
 
   /** Allocates a new string from UTF-8 data.*/
   static V8_DEPRECATE_SOON(
       "Use maybe version",
       Local<String> NewFromUtf8(Isolate* isolate, const char* data,
                                 NewStringType type = kNormalString,
                                 int length = -1));
 
   /** Allocates a new string from UTF-8 data. Only returns an empty value when
    * length > kMaxLength. **/
-  static MaybeLocal<String> NewFromUtf8(Isolate* isolate, const char* data,
-                                        v8::NewStringType type,
-                                        int length = -1);
+  static V8_WARN_UNUSED_RESULT MaybeLocal<String> NewFromUtf8(
+      Isolate* isolate, const char* data, v8::NewStringType type,
+      int length = -1);
 
   /** Allocates a new string from Latin-1 data.*/
   static V8_DEPRECATE_SOON(
       "Use maybe version",
       Local<String> NewFromOneByte(Isolate* isolate, const uint8_t* data,
                                    NewStringType type = kNormalString,
                                    int length = -1));
 
   /** Allocates a new string from Latin-1 data.  Only returns an empty value
    * when length > kMaxLength. **/
-  static MaybeLocal<String> NewFromOneByte(Isolate* isolate,
-                                           const uint8_t* data,
-                                           v8::NewStringType type,
-                                           int length = -1);
+  static V8_WARN_UNUSED_RESULT MaybeLocal<String> NewFromOneByte(
+      Isolate* isolate, const uint8_t* data, v8::NewStringType type,
+      int length = -1);
 
   /** Allocates a new string from UTF-16 data.*/
   static V8_DEPRECATE_SOON(
       "Use maybe version",
       Local<String> NewFromTwoByte(Isolate* isolate, const uint16_t* data,
                                    NewStringType type = kNormalString,
                                    int length = -1));
 
   /** Allocates a new string from UTF-16 data. Only returns an empty value when
    * length > kMaxLength. **/
-  static MaybeLocal<String> NewFromTwoByte(Isolate* isolate,
-                                           const uint16_t* data,
-                                           v8::NewStringType type,
-                                           int length = -1);
+  static V8_WARN_UNUSED_RESULT MaybeLocal<String> NewFromTwoByte(
+      Isolate* isolate, const uint16_t* data, v8::NewStringType type,
+      int length = -1);
 
   /**
    * Creates a new string by concatenating the left and the right strings
    * passed in as parameters.
    */
   static Local<String> Concat(Handle<String> left, Handle<String> right);
 
   /**
    * Creates a new external string using the data defined in the given
    * resource. When the external string is no longer live on V8's heap the
    * resource will be disposed by calling its Dispose method. The caller of
    * this function should not otherwise delete or modify the resource. Neither
    * should the underlying buffer be deallocated or modified except through the
    * destructor of the external string resource.
    */
   static V8_DEPRECATE_SOON(
       "Use maybe version",
       Local<String> NewExternal(Isolate* isolate,
                                 ExternalStringResource* resource));
-  static MaybeLocal<String> NewExternalTwoByte(
+  static V8_WARN_UNUSED_RESULT MaybeLocal<String> NewExternalTwoByte(
       Isolate* isolate, ExternalStringResource* resource);
 
   /**
    * Associate an external string resource with this string by transforming it
    * in place so that existing references to this string in the JavaScript heap
    * will use the external string resource. The external string resource's
    * character contents need to be equivalent to this string.
    * Returns true if the string has been changed to be an external string.
    * The string is not modified if the operation fails. See NewExternal for
    * information on the lifetime of the resource.
    */
   bool MakeExternal(ExternalStringResource* resource);
 
   /**
    * Creates a new external string using the one-byte data defined in the given
    * resource. When the external string is no longer live on V8's heap the
    * resource will be disposed by calling its Dispose method. The caller of
    * this function should not otherwise delete or modify the resource. Neither
    * should the underlying buffer be deallocated or modified except through the
    * destructor of the external string resource.
    */
   static V8_DEPRECATE_SOON(
       "Use maybe version",
       Local<String> NewExternal(Isolate* isolate,
                                 ExternalOneByteStringResource* resource));
-  static MaybeLocal<String> NewExternalOneByte(
+  static V8_WARN_UNUSED_RESULT MaybeLocal<String> NewExternalOneByte(
       Isolate* isolate, ExternalOneByteStringResource* resource);
 
   /**
    * Associate an external string resource with this string by transforming it
    * in place so that existing references to this string in the JavaScript heap
    * will use the external string resource. The external string resource's
    * character contents need to be equivalent to this string.
    * Returns true if the string has been changed to be an external string.
    * The string is not modified if the operation fails. See NewExternal for
    * information on the lifetime of the resource.
@@ skipping 251 matching lines @@
 };
 
 
 /**
  * A JavaScript object (ECMA-262, 4.3.3)
  */
 class V8_EXPORT Object : public Value {
  public:
   V8_DEPRECATE_SOON("Use maybe version",
                     bool Set(Handle<Value> key, Handle<Value> value));
-  Maybe<bool> Set(Local<Context> context, Local<Value> key, Local<Value> value);
+  V8_WARN_UNUSED_RESULT Maybe<bool> Set(Local<Context> context,
+                                        Local<Value> key, Local<Value> value);
 
   V8_DEPRECATE_SOON("Use maybe version",
                     bool Set(uint32_t index, Handle<Value> value));
-  Maybe<bool> Set(Local<Context> context, uint32_t index, Local<Value> value);
+  V8_WARN_UNUSED_RESULT Maybe<bool> Set(Local<Context> context, uint32_t index,
+                                        Local<Value> value);
 
   // Sets an own property on this object bypassing interceptors and
   // overriding accessors or read-only properties.
   //
   // Note that if the object has an interceptor the property will be set
   // locally, but since the interceptor takes precedence the local property
   // will only be returned if the interceptor doesn't return a value.
   //
   // Note also that this only works for named properties.
   V8_DEPRECATE_SOON("Use maybe version",
                     bool ForceSet(Handle<Value> key, Handle<Value> value,
                                   PropertyAttribute attribs = None));
+  // TODO(dcarney): mark V8_WARN_UNUSED_RESULT
   Maybe<bool> ForceSet(Local<Context> context, Local<Value> key,
                        Local<Value> value, PropertyAttribute attribs = None);
 
   V8_DEPRECATE_SOON("Use maybe version", Local<Value> Get(Handle<Value> key));
-  MaybeLocal<Value> Get(Local<Context> context, Local<Value> key);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Value> Get(Local<Context> context,
+                                              Local<Value> key);
 
   V8_DEPRECATE_SOON("Use maybe version", Local<Value> Get(uint32_t index));
-  MaybeLocal<Value> Get(Local<Context> context, uint32_t index);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Value> Get(Local<Context> context,
+                                              uint32_t index);
 
   /**
    * Gets the property attributes of a property which can be None or
    * any combination of ReadOnly, DontEnum and DontDelete. Returns
    * None when the property doesn't exist.
    */
   V8_DEPRECATE_SOON("Use maybe version",
                     PropertyAttribute GetPropertyAttributes(Handle<Value> key));
-  Maybe<PropertyAttribute> GetPropertyAttributes(Local<Context> context,
-                                                 Local<Value> key);
+  V8_WARN_UNUSED_RESULT Maybe<PropertyAttribute> GetPropertyAttributes(
+      Local<Context> context, Local<Value> key);
 
   /**
    * Returns Object.getOwnPropertyDescriptor as per ES5 section 15.2.3.3.
    */
   V8_DEPRECATE_SOON("Use maybe version",
                     Local<Value> GetOwnPropertyDescriptor(Local<String> key));
-  MaybeLocal<Value> GetOwnPropertyDescriptor(Local<Context> context,
-                                             Local<String> key);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Value> GetOwnPropertyDescriptor(
+      Local<Context> context, Local<String> key);
 
   V8_DEPRECATE_SOON("Use maybe version", bool Has(Handle<Value> key));
-  Maybe<bool> Has(Local<Context> context, Local<Value> key);
+  V8_WARN_UNUSED_RESULT Maybe<bool> Has(Local<Context> context,
+                                        Local<Value> key);
 
   V8_DEPRECATE_SOON("Use maybe version", bool Delete(Handle<Value> key));
+  // TODO(dcarney): mark V8_WARN_UNUSED_RESULT
   Maybe<bool> Delete(Local<Context> context, Local<Value> key);
 
   V8_DEPRECATE_SOON("Use maybe version", bool Has(uint32_t index));
-  Maybe<bool> Has(Local<Context> context, uint32_t index);
+  V8_WARN_UNUSED_RESULT Maybe<bool> Has(Local<Context> context, uint32_t index);
 
   V8_DEPRECATE_SOON("Use maybe version", bool Delete(uint32_t index));
+  // TODO(dcarney): mark V8_WARN_UNUSED_RESULT
   Maybe<bool> Delete(Local<Context> context, uint32_t index);
 
   V8_DEPRECATE_SOON("Use maybe version",
                     bool SetAccessor(Handle<String> name,
                                      AccessorGetterCallback getter,
                                      AccessorSetterCallback setter = 0,
                                      Handle<Value> data = Handle<Value>(),
                                      AccessControl settings = DEFAULT,
                                      PropertyAttribute attribute = None));
   V8_DEPRECATE_SOON("Use maybe version",
                     bool SetAccessor(Handle<Name> name,
                                      AccessorNameGetterCallback getter,
                                      AccessorNameSetterCallback setter = 0,
                                      Handle<Value> data = Handle<Value>(),
                                      AccessControl settings = DEFAULT,
                                      PropertyAttribute attribute = None));
+  // TODO(dcarney): mark V8_WARN_UNUSED_RESULT
   Maybe<bool> SetAccessor(Local<Context> context, Local<Name> name,
                           AccessorNameGetterCallback getter,
                           AccessorNameSetterCallback setter = 0,
                           MaybeLocal<Value> data = MaybeLocal<Value>(),
                           AccessControl settings = DEFAULT,
                           PropertyAttribute attribute = None);
 
   void SetAccessorProperty(Local<Name> name,
                            Local<Function> getter,
                            Handle<Function> setter = Handle<Function>(),
@@ skipping 12 matching lines @@
   bool DeletePrivate(Handle<Private> key);
   Local<Value> GetPrivate(Handle<Private> key);
 
   /**
    * Returns an array containing the names of the enumerable properties
    * of this object, including properties from prototype objects.  The
    * array returned by this method contains the same values as would
    * be enumerated by a for-in statement over this object.
    */
   V8_DEPRECATE_SOON("Use maybe version", Local<Array> GetPropertyNames());
-  MaybeLocal<Array> GetPropertyNames(Local<Context> context);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Array> GetPropertyNames(
+      Local<Context> context);
 
   /**
    * This function has the same functionality as GetPropertyNames but
    * the returned array doesn't contain the names of properties from
    * prototype objects.
    */
   V8_DEPRECATE_SOON("Use maybe version", Local<Array> GetOwnPropertyNames());
-  MaybeLocal<Array> GetOwnPropertyNames(Local<Context> context);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Array> GetOwnPropertyNames(
+      Local<Context> context);
 
   /**
    * Get the prototype object.  This does not skip objects marked to
    * be skipped by __proto__ and it does not consult the security
    * handler.
    */
   Local<Value> GetPrototype();
 
   /**
    * Set the prototype object.  This does not skip objects marked to
    * be skipped by __proto__ and it does not consult the security
    * handler.
    */
   V8_DEPRECATE_SOON("Use maybe version",
                     bool SetPrototype(Handle<Value> prototype));
-  Maybe<bool> SetPrototype(Local<Context> context, Local<Value> prototype);
+  V8_WARN_UNUSED_RESULT Maybe<bool> SetPrototype(Local<Context> context,
+                                                 Local<Value> prototype);
 
   /**
    * Finds an instance of the given function template in the prototype
    * chain.
    */
   Local<Object> FindInstanceInPrototypeChain(Handle<FunctionTemplate> tmpl);
 
   /**
    * Call builtin Object.prototype.toString on this object.
    * This is different from Value::ToString() that may call
    * user-defined toString function. This one does not.
    */
   V8_DEPRECATE_SOON("Use maybe version", Local<String> ObjectProtoToString());
-  MaybeLocal<String> ObjectProtoToString(Local<Context> context);
+  V8_WARN_UNUSED_RESULT MaybeLocal<String> ObjectProtoToString(
+      Local<Context> context);
 
   /**
    * Returns the name of the function invoked as a constructor for this object.
    */
   Local<String> GetConstructorName();
 
   /** Gets the number of internal fields for this Object. */
   int InternalFieldCount();
 
   /** Same as above, but works for Persistents */
@@ skipping 24 matching lines @@
   /**
    * Sets a 2-byte-aligned native pointer in an internal field. To retrieve such
    * a field, GetAlignedPointerFromInternalField must be used, everything else
    * leads to undefined behavior.
    */
   void SetAlignedPointerInInternalField(int index, void* value);
 
   // Testers for local properties.
   V8_DEPRECATE_SOON("Use maybe version",
                     bool HasOwnProperty(Handle<String> key));
-  Maybe<bool> HasOwnProperty(Local<Context> context, Local<Name> key);
+  V8_WARN_UNUSED_RESULT Maybe<bool> HasOwnProperty(Local<Context> context,
+                                                   Local<Name> key);
   V8_DEPRECATE_SOON("Use maybe version",
                     bool HasRealNamedProperty(Handle<String> key));
-  Maybe<bool> HasRealNamedProperty(Local<Context> context, Local<Name> key);
+  V8_WARN_UNUSED_RESULT Maybe<bool> HasRealNamedProperty(Local<Context> context,
+                                                         Local<Name> key);
   V8_DEPRECATE_SOON("Use maybe version",
                     bool HasRealIndexedProperty(uint32_t index));
-  Maybe<bool> HasRealIndexedProperty(Local<Context> context, uint32_t index);
+  V8_WARN_UNUSED_RESULT Maybe<bool> HasRealIndexedProperty(
+      Local<Context> context, uint32_t index);
   V8_DEPRECATE_SOON("Use maybe version",
                     bool HasRealNamedCallbackProperty(Handle<String> key));
-  Maybe<bool> HasRealNamedCallbackProperty(Local<Context> context,
-                                           Local<Name> key);
+  V8_WARN_UNUSED_RESULT Maybe<bool> HasRealNamedCallbackProperty(
+      Local<Context> context, Local<Name> key);
 
   /**
    * If result.IsEmpty() no real property was located in the prototype chain.
    * This means interceptors in the prototype chain are not called.
    */
   V8_DEPRECATE_SOON(
       "Use maybe version",
       Local<Value> GetRealNamedPropertyInPrototypeChain(Handle<String> key));
-  MaybeLocal<Value> GetRealNamedPropertyInPrototypeChain(Local<Context> context,
-                                                         Local<Name> key);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Value> GetRealNamedPropertyInPrototypeChain(
+      Local<Context> context, Local<Name> key);
 
   /**
    * Gets the property attributes of a real property in the prototype chain,
    * which can be None or any combination of ReadOnly, DontEnum and DontDelete.
    * Interceptors in the prototype chain are not called.
    */
   V8_DEPRECATE_SOON(
       "Use maybe version",
       Maybe<PropertyAttribute> GetRealNamedPropertyAttributesInPrototypeChain(
           Handle<String> key));
-  Maybe<PropertyAttribute> GetRealNamedPropertyAttributesInPrototypeChain(
-      Local<Context> context, Local<Name> key);
+  V8_WARN_UNUSED_RESULT Maybe<PropertyAttribute>
+  GetRealNamedPropertyAttributesInPrototypeChain(Local<Context> context,
+                                                 Local<Name> key);
 
   /**
    * If result.IsEmpty() no real property was located on the object or
    * in the prototype chain.
    * This means interceptors in the prototype chain are not called.
    */
   V8_DEPRECATE_SOON("Use maybe version",
                     Local<Value> GetRealNamedProperty(Handle<String> key));
-  MaybeLocal<Value> GetRealNamedProperty(Local<Context> context,
-                                         Local<Name> key);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Value> GetRealNamedProperty(
+      Local<Context> context, Local<Name> key);
 
   /**
    * Gets the property attributes of a real property which can be
    * None or any combination of ReadOnly, DontEnum and DontDelete.
    * Interceptors in the prototype chain are not called.
    */
   V8_DEPRECATE_SOON("Use maybe version",
                     Maybe<PropertyAttribute> GetRealNamedPropertyAttributes(
                         Handle<String> key));
-  Maybe<PropertyAttribute> GetRealNamedPropertyAttributes(
+  V8_WARN_UNUSED_RESULT Maybe<PropertyAttribute> GetRealNamedPropertyAttributes(
       Local<Context> context, Local<Name> key);
 
   /** Tests for a named lookup interceptor.*/
   bool HasNamedLookupInterceptor();
 
   /** Tests for an index lookup interceptor.*/
   bool HasIndexedLookupInterceptor();
 
   /**
    * Turns on access check on the object if the object is an instance of
@@ skipping 68 matching lines @@
    */
   bool IsCallable();
 
   /**
    * Call an Object as a function if a callback is set by the
    * ObjectTemplate::SetCallAsFunctionHandler method.
    */
   V8_DEPRECATE_SOON("Use maybe version",
                     Local<Value> CallAsFunction(Handle<Value> recv, int argc,
                                                 Handle<Value> argv[]));
-  MaybeLocal<Value> CallAsFunction(Local<Context> context, Handle<Value> recv,
-                                   int argc, Handle<Value> argv[]);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Value> CallAsFunction(Local<Context> context,
+                                                         Handle<Value> recv,
+                                                         int argc,
+                                                         Handle<Value> argv[]);
 
   /**
    * Call an Object as a constructor if a callback is set by the
    * ObjectTemplate::SetCallAsFunctionHandler method.
    * Note: This method behaves like the Function::NewInstance method.
    */
   V8_DEPRECATE_SOON("Use maybe version",
                     Local<Value> CallAsConstructor(int argc,
                                                    Handle<Value> argv[]));
-  MaybeLocal<Value> CallAsConstructor(Local<Context> context, int argc,
-                                      Local<Value> argv[]);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Value> CallAsConstructor(
+      Local<Context> context, int argc, Local<Value> argv[]);
 
   /**
    * Return the isolate to which the Object belongs to.
    */
   V8_DEPRECATE_SOON("Keep track of isolate correctly", Isolate* GetIsolate());
 
   static Local<Object> New(Isolate* isolate);
 
   V8_INLINE static Object* Cast(Value* obj);
 
@@ skipping 11 matching lines @@
 class V8_EXPORT Array : public Object {
  public:
   uint32_t Length() const;
 
   /**
    * Clones an element at index |index|.  Returns an empty
    * handle if cloning fails (for any reason).
    */
   V8_DEPRECATE_SOON("Use maybe version",
                     Local<Object> CloneElementAt(uint32_t index));
-  MaybeLocal<Object> CloneElementAt(Local<Context> context, uint32_t index);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Object> CloneElementAt(
+      Local<Context> context, uint32_t index);
 
   /**
    * Creates a JavaScript array with the given length. If the length
    * is negative the returned array will have length 0.
    */
   static Local<Array> New(Isolate* isolate, int length = 0);
 
   V8_INLINE static Array* Cast(Value* obj);
  private:
   Array();
@@ skipping 127 matching lines @@
    * for a given FunctionCallback.
    */
   static Local<Function> New(Isolate* isolate,
                              FunctionCallback callback,
                              Local<Value> data = Local<Value>(),
                              int length = 0);
 
   V8_DEPRECATE_SOON("Use maybe version",
                     Local<Object> NewInstance(int argc,
                                               Handle<Value> argv[])) const;
-  MaybeLocal<Object> NewInstance(Local<Context> context, int argc,
-                                 Handle<Value> argv[]) const;
+  V8_WARN_UNUSED_RESULT MaybeLocal<Object> NewInstance(
+      Local<Context> context, int argc, Handle<Value> argv[]) const;
 
   V8_DEPRECATE_SOON("Use maybe version", Local<Object> NewInstance()) const;
-  MaybeLocal<Object> NewInstance(Local<Context> context) const {
+  V8_WARN_UNUSED_RESULT MaybeLocal<Object> NewInstance(
+      Local<Context> context) const {
     return NewInstance(context, 0, nullptr);
   }
 
   V8_DEPRECATE_SOON("Use maybe version",
                     Local<Value> Call(Handle<Value> recv, int argc,
                                       Handle<Value> argv[]));
-  MaybeLocal<Value> Call(Local<Context> context, Handle<Value> recv, int argc,
-                         Handle<Value> argv[]);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Value> Call(Local<Context> context,
+                                               Handle<Value> recv, int argc,
+                                               Handle<Value> argv[]);
 
   void SetName(Handle<String> name);
   Handle<Value> GetName() const;
 
   /**
    * Name inferred from variable or property assignment of this function.
    * Used to facilitate debugging and profiling of JavaScript code written
    * in an OO style, where many functions are anonymous but are assigned
    * to object properties.
    */
@@ skipping 48 matching lines @@
  */
 class V8_EXPORT Promise : public Object {
  public:
   class V8_EXPORT Resolver : public Object {
    public:
     /**
      * Create a new resolver, along with an associated promise in pending state.
      */
     static V8_DEPRECATE_SOON("Use maybe version",
                              Local<Resolver> New(Isolate* isolate));
-    static MaybeLocal<Resolver> New(Local<Context> context);
+    static V8_WARN_UNUSED_RESULT MaybeLocal<Resolver> New(
+        Local<Context> context);
 
     /**
      * Extract the associated promise.
      */
     Local<Promise> GetPromise();
 
     /**
      * Resolve/reject the associated promise with a given value.
      * Ignored if the promise is no longer pending.
      */
     V8_DEPRECATE_SOON("Use maybe version", void Resolve(Handle<Value> value));
+    // TODO(dcarney): mark V8_WARN_UNUSED_RESULT
     Maybe<bool> Resolve(Local<Context> context, Handle<Value> value);
 
     V8_DEPRECATE_SOON("Use maybe version", void Reject(Handle<Value> value));
+    // TODO(dcarney): mark V8_WARN_UNUSED_RESULT
     Maybe<bool> Reject(Local<Context> context, Handle<Value> value);
 
     V8_INLINE static Resolver* Cast(Value* obj);
 
    private:
     Resolver();
     static void CheckCast(Value* obj);
   };
 
   /**
    * Register a resolution/rejection handler with a promise.
    * The handler is given the respective resolution/rejection value as
    * an argument. If the promise is already resolved/rejected, the handler is
    * invoked at the end of turn.
    */
   V8_DEPRECATE_SOON("Use maybe version",
                     Local<Promise> Chain(Handle<Function> handler));
-  MaybeLocal<Promise> Chain(Local<Context> context, Handle<Function> handler);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Promise> Chain(Local<Context> context,
+                                                  Handle<Function> handler);
 
   V8_DEPRECATE_SOON("Use maybe version",
                     Local<Promise> Catch(Handle<Function> handler));
-  MaybeLocal<Promise> Catch(Local<Context> context, Handle<Function> handler);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Promise> Catch(Local<Context> context,
+                                                  Handle<Function> handler);
 
   V8_DEPRECATE_SOON("Use maybe version",
                     Local<Promise> Then(Handle<Function> handler));
-  MaybeLocal<Promise> Then(Local<Context> context, Handle<Function> handler);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Promise> Then(Local<Context> context,
+                                                 Handle<Function> handler);
 
   /**
    * Returns true if the promise has at least one derived promise, and
    * therefore resolve/reject handlers (including default handler).
    */
   bool HasHandler();
 
   V8_INLINE static Promise* Cast(Value* obj);
 
  private:
@@ skipping 347 matching lines @@
 };
 
 
 /**
  * An instance of the built-in Date constructor (ECMA-262, 15.9).
  */
 class V8_EXPORT Date : public Object {
  public:
   static V8_DEPRECATE_SOON("Use maybe version.",
                            Local<Value> New(Isolate* isolate, double time));
-  static MaybeLocal<Value> New(Local<Context> context, double time);
+  static V8_WARN_UNUSED_RESULT MaybeLocal<Value> New(Local<Context> context,
+                                                     double time);
 
   /**
    * A specialization of Value::NumberValue that is more efficient
    * because we know the structure of this object.
    */
   double ValueOf() const;
 
   V8_INLINE static Date* Cast(v8::Value* obj);
 
   /**
@@ skipping 103 matching lines @@
    * described in ECMA-262, 15.10.4.1.
    *
    * For example,
    *   RegExp::New(v8::String::New("foo"),
    *               static_cast<RegExp::Flags>(kGlobal | kMultiline))
    * is equivalent to evaluating "/foo/gm".
    */
   static V8_DEPRECATE_SOON("Use maybe version",
                            Local<RegExp> New(Handle<String> pattern,
                                              Flags flags));
-  static MaybeLocal<RegExp> New(Local<Context> context, Handle<String> pattern,
-                                Flags flags);
+  static V8_WARN_UNUSED_RESULT MaybeLocal<RegExp> New(Local<Context> context,
+                                                      Handle<String> pattern,
+                                                      Flags flags);
 
   /**
    * Returns the value of the source property: a string representing
    * the regular expression.
    */
   Local<String> GetSource() const;
 
   /**
    * Returns the flags bit field.
    */
@@ skipping 364 matching lines @@
   /** Creates a function template.*/
   static Local<FunctionTemplate> New(
       Isolate* isolate,
       FunctionCallback callback = 0,
       Handle<Value> data = Handle<Value>(),
       Handle<Signature> signature = Handle<Signature>(),
       int length = 0);
 
   /** Returns the unique function instance in the current execution context.*/
   V8_DEPRECATE_SOON("Use maybe version", Local<Function> GetFunction());
-  MaybeLocal<Function> GetFunction(Local<Context> context);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Function> GetFunction(
+      Local<Context> context);
 
   /**
    * Set the call-handler callback for a FunctionTemplate.  This
    * callback is called whenever the function created from this
    * FunctionTemplate is called.
    */
   void SetCallHandler(FunctionCallback callback,
                       Handle<Value> data = Handle<Value>());
 
   /** Set the predefined length property for the FunctionTemplate. */
@@ skipping 140 matching lines @@
  * created from the ObjectTemplate.
  */
 class V8_EXPORT ObjectTemplate : public Template {
  public:
   /** Creates an ObjectTemplate. */
   static Local<ObjectTemplate> New(Isolate* isolate);
   static V8_DEPRECATE_SOON("Use isolate version", Local<ObjectTemplate> New());
 
   /** Creates a new instance of this template.*/
   V8_DEPRECATE_SOON("Use maybe version", Local<Object> NewInstance());
-  MaybeLocal<Object> NewInstance(Local<Context> context);
+  V8_WARN_UNUSED_RESULT MaybeLocal<Object> NewInstance(Local<Context> context);
 
   /**
    * Sets an accessor on the object template.
    *
    * Whenever the property with the given name is accessed on objects
    * created from this ObjectTemplate the getter and setter callbacks
    * are called instead of getting and setting the property directly
    * on the JavaScript object.
    *
    * \param name The name of the property for which an accessor is added.
@@ skipping 1821 matching lines @@
    *
    * The returned handle is valid until this TryCatch block has been destroyed.
    */
   Local<Value> Exception() const;
 
   /**
    * Returns the .stack property of the thrown object.  If no .stack
    * property is present an empty handle is returned.
    */
   V8_DEPRECATE_SOON("Use maybe version.", Local<Value> StackTrace()) const;
-  MaybeLocal<Value> StackTrace(Local<Context> context) const;
+  V8_WARN_UNUSED_RESULT MaybeLocal<Value> StackTrace(
+      Local<Context> context) const;
 
   /**
    * Returns the message associated with this exception.  If there is
    * no message associated an empty handle is returned.
    *
    * The returned handle is valid until this TryCatch block has been
    * destroyed.
    */
   Local<v8::Message> Message() const;
 
@@ skipping 1846 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_