[api] Use shorter 8::Local::As<*> casts in more places

Bug: v8:11195
Change-Id: I19211af9e440940f85351fb38920eb620c222213
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2555010
Reviewed-by: Ross McIlroy <[email protected]>
Reviewed-by: Victor Gomes <[email protected]>
Commit-Queue: Camillo Bruni <[email protected]>
Cr-Commit-Position: refs/heads/master@{#71465}

samples/process.cc

@@ -219,7 +219,7 @@ bool JsHttpRequestProcessor::Initialize(map<string, string>* opts,
   }
 
   // It is a function; cast it to a Function
-  Local<Function> process_fun = Local<Function>::Cast(process_val);
+  Local<Function> process_fun = process_val.As<Function>();
 
   // Store the function in a Global handle, since we also want
   // that to remain after this call returns
@@ -375,7 +375,7 @@ Local<Object> JsHttpRequestProcessor::WrapMap(map<string, string>* obj) {
 // Utility function that extracts the C++ map pointer from a wrapper
 // object.
 map<string, string>* JsHttpRequestProcessor::UnwrapMap(Local<Object> obj) {
-  Local<External> field = Local<External>::Cast(obj->GetInternalField(0));
+  Local<External> field = obj->GetInternalField(0).As<External>();
   void* ptr = field->Value();
   return static_cast<map<string, string>*>(ptr);
 }
@@ -397,7 +397,7 @@ void JsHttpRequestProcessor::MapGet(Local<Name> name,
   map<string, string>* obj = UnwrapMap(info.Holder());
 
   // Convert the JavaScript string to a std::string.
-  string key = ObjectToString(info.GetIsolate(), Local<String>::Cast(name));
+  string key = ObjectToString(info.GetIsolate(), name.As<String>());
 
   // Look up the value if it exists using the standard STL ideom.
   map<string, string>::iterator iter = obj->find(key);
@@ -422,7 +422,7 @@ void JsHttpRequestProcessor::MapSet(Local<Name> name, Local<Value> value_obj,
   map<string, string>* obj = UnwrapMap(info.Holder());
 
   // Convert the key and value to std::strings.
-  string key = ObjectToString(info.GetIsolate(), Local<String>::Cast(name));
+  string key = ObjectToString(info.GetIsolate(), name.As<String>());
   string value = ObjectToString(info.GetIsolate(), value_obj);
 
   // Update the map.
@@ -491,7 +491,7 @@ Local<Object> JsHttpRequestProcessor::WrapRequest(HttpRequest* request) {
  * wrapper object.
  */
 HttpRequest* JsHttpRequestProcessor::UnwrapRequest(Local<Object> obj) {
-  Local<External> field = Local<External>::Cast(obj->GetInternalField(0));
+  Local<External> field = obj->GetInternalField(0).As<External>();
   void* ptr = field->Value();
   return static_cast<HttpRequest*>(ptr);
 }

samples/shell.cc

@@ -380,7 +380,7 @@ void ReportException(v8::Isolate* isolate, v8::TryCatch* try_catch) {
     v8::Local<v8::Value> stack_trace_string;
     if (try_catch->StackTrace(context).ToLocal(&stack_trace_string) &&
         stack_trace_string->IsString() &&
-        v8::Local<v8::String>::Cast(stack_trace_string)->Length() > 0) {
+        stack_trace_string.As<v8::String>()->Length() > 0) {
       v8::String::Utf8Value stack_trace(isolate, stack_trace_string);
       const char* stack_trace_string = ToCString(stack_trace);
       fprintf(stderr, "%s\n", stack_trace_string);

src/d8/async-hooks-wrapper.cc

@@ -52,7 +52,7 @@ static AsyncHooksWrap* UnwrapHook(
     return nullptr;
   }
 
-  Local<External> wrap = Local<External>::Cast(hook->GetInternalField(0));
+  Local<External> wrap = hook->GetInternalField(0).As<External>();
   void* ptr = wrap->Value();
   return static_cast<AsyncHooksWrap*>(ptr);
 }

src/d8/d8-posix.cc

@@ -423,7 +423,7 @@ void Shell::System(const v8::FunctionCallbackInfo<v8::Value>& args) {
           args.GetIsolate(), "system: Argument 2 must be an array"));
       return;
     }
-    command_args = Local<Array>::Cast(args[1]);
+    command_args = args[1].As<Array>();
   } else {
     command_args = Array::New(args.GetIsolate(), 0);
   }

src/d8/d8.cc

@@ -397,7 +397,7 @@ class TraceConfigParser {
     Local<String> source =
         String::NewFromUtf8(isolate, json_str).ToLocalChecked();
     Local<Value> result = JSON::Parse(context, source).ToLocalChecked();
-    Local<v8::Object> trace_config_object = Local<v8::Object>::Cast(result);
+    Local<v8::Object> trace_config_object = result.As<v8::Object>();
 
     UpdateIncludedCategoriesList(isolate, context, trace_config_object,
                                  trace_config);
@@ -410,7 +410,7 @@ class TraceConfigParser {
     Local<Value> value =
         GetValue(isolate, context, object, kIncludedCategoriesParam);
     if (value->IsArray()) {
-      Local<Array> v8_array = Local<Array>::Cast(value);
+      Local<Array> v8_array = value.As<Array>();
       for (int i = 0, length = v8_array->Length(); i < length; ++i) {
         Local<Value> v = v8_array->Get(context, i)
                              .ToLocalChecked()
@@ -1029,8 +1029,7 @@ MaybeLocal<Promise> Shell::HostImportModuleDynamically(
   Local<Promise::Resolver> resolver;
   if (maybe_resolver.ToLocal(&resolver)) {
     DynamicImportData* data = new DynamicImportData(
-        isolate, Local<String>::Cast(referrer->GetResourceName()), specifier,
-        resolver);
+        isolate, referrer->GetResourceName().As<String>(), specifier, resolver);
     isolate->EnqueueMicrotask(Shell::DoHostImportModuleDynamically, data);
     return resolver->GetPromise();
   }
@@ -1108,7 +1107,7 @@ void Shell::DoHostImportModuleDynamically(void* import_data) {
 
   Local<Value> module_namespace = root_module->GetModuleNamespace();
   if (i::FLAG_harmony_top_level_await) {
-    Local<Promise> result_promise(Local<Promise>::Cast(result));
+    Local<Promise> result_promise(result.As<Promise>());
     if (result_promise->State() == Promise::kRejected) {
       resolver->Reject(realm, result_promise->Result()).ToChecked();
       return;
@@ -1176,7 +1175,7 @@ bool Shell::ExecuteModule(Isolate* isolate, const char* file_name) {
     // Loop until module execution finishes
     // TODO(cbruni): This is a bit wonky. "Real" engines would not be
     // able to just busy loop waiting for execution to finish.
-    Local<Promise> result_promise(Local<Promise>::Cast(result));
+    Local<Promise> result_promise(result.As<Promise>());
     while (result_promise->State() == Promise::kPending) {
       isolate->PerformMicrotaskCheckpoint();
     }
@@ -1653,7 +1652,7 @@ void WriteToFile(FILE* file, const v8::FunctionCallbackInfo<v8::Value>& args) {
     Local<String> str_obj;
 
     if (arg->IsSymbol()) {
-      arg = Local<Symbol>::Cast(arg)->Description();
+      arg = arg.As<Symbol>()->Description();
     }
     if (!arg->ToString(args.GetIsolate()->GetCurrentContext())
              .ToLocal(&str_obj)) {
@@ -1776,7 +1775,7 @@ void Shell::SetTimeout(const v8::FunctionCallbackInfo<v8::Value>& args) {
   Isolate* isolate = args.GetIsolate();
   args.GetReturnValue().Set(v8::Number::New(isolate, 0));
   if (args.Length() == 0 || !args[0]->IsFunction()) return;
-  Local<Function> callback = Local<Function>::Cast(args[0]);
+  Local<Function> callback = args[0].As<Function>();
   Local<Context> context = isolate->GetCurrentContext();
   PerIsolateData::Get(isolate)->SetTimeout(callback, context);
 }
@@ -1879,7 +1878,7 @@ void Shell::WorkerPostMessage(const v8::FunctionCallbackInfo<v8::Value>& args) {
 
   Local<Value> message = args[0];
   Local<Value> transfer =
-      args.Length() >= 2 ? args[1] : Local<Value>::Cast(Undefined(isolate));
+      args.Length() >= 2 ? args[1] : Undefined(isolate).As<Value>();
   std::unique_ptr<SerializationData> data =
       Shell::SerializeValue(isolate, message, transfer);
   if (data) {
@@ -2065,8 +2064,7 @@ void Shell::ReportException(Isolate* isolate, Local<v8::Message> message,
   if (v8::TryCatch::StackTrace(context, exception_obj)
           .ToLocal(&stack_trace_string) &&
       stack_trace_string->IsString()) {
-    v8::String::Utf8Value stack_trace(isolate,
-                                      Local<String>::Cast(stack_trace_string));
+    v8::String::Utf8Value stack_trace(isolate, stack_trace_string.As<String>());
     printf("%s\n", ToCString(stack_trace));
   }
   printf("\n");
@@ -2858,11 +2856,10 @@ class InspectorFrontend final : public v8_inspector::V8Inspector::Channel {
     if (callback->IsFunction()) {
       v8::TryCatch try_catch(isolate_);
       Local<Value> args[] = {message};
-      USE(Local<Function>::Cast(callback)->Call(context, Undefined(isolate_), 1,
-                                                args));
+      USE(callback.As<Function>()->Call(context, Undefined(isolate_), 1, args));
 #ifdef DEBUG
       if (try_catch.HasCaught()) {
-        Local<Object> exception = Local<Object>::Cast(try_catch.Exception());
+        Local<Object> exception = try_catch.Exception().As<Object>();
         Local<String> key = v8::String::NewFromUtf8Literal(
             isolate_, "message", NewStringType::kInternalized);
         Local<String> expected = v8::String::NewFromUtf8Literal(
@@ -2917,8 +2914,7 @@ class InspectorClient : public v8_inspector::V8InspectorClient {
     is_paused = true;
 
     while (is_paused) {
-      USE(Local<Function>::Cast(callback)->Call(context, Undefined(isolate_), 0,
-                                                {}));
+      USE(callback.As<Function>()->Call(context, Undefined(isolate_), 0, {}));
       if (try_catch.HasCaught()) {
         is_paused = false;
       }
@@ -3293,7 +3289,7 @@ void Worker::ProcessMessage(std::unique_ptr<SerializationData> data) {
   if (!onmessage->IsFunction()) {
     return;
   }
-  Local<Function> onmessage_fun = Local<Function>::Cast(onmessage);
+  Local<Function> onmessage_fun = onmessage.As<Function>();
 
   v8::TryCatch try_catch(isolate_);
   try_catch.SetVerbose(true);
@@ -3419,7 +3415,7 @@ void Worker::PostMessageOut(const v8::FunctionCallbackInfo<v8::Value>& args) {
       Shell::SerializeValue(isolate, message, transfer);
   if (data) {
     DCHECK(args.Data()->IsExternal());
-    Local<External> this_value = Local<External>::Cast(args.Data());
+    Local<External> this_value = args.Data().As<External>();
     Worker* worker = static_cast<Worker*>(this_value->Value());
     worker->out_queue_.Enqueue(std::move(data));
     worker->out_semaphore_.Signal();
@@ -3954,7 +3950,7 @@ class Serializer : public ValueSerializer::Delegate {
  private:
   Maybe<bool> PrepareTransfer(Local<Context> context, Local<Value> transfer) {
     if (transfer->IsArray()) {
-      Local<Array> transfer_array = Local<Array>::Cast(transfer);
+      Local<Array> transfer_array = transfer.As<Array>();
       uint32_t length = transfer_array->Length();
       for (uint32_t i = 0; i < length; ++i) {
         Local<Value> element;
@@ -3964,7 +3960,7 @@ class Serializer : public ValueSerializer::Delegate {
             return Nothing<bool>();
           }
 
-          Local<ArrayBuffer> array_buffer = Local<ArrayBuffer>::Cast(element);
+          Local<ArrayBuffer> array_buffer = element.As<ArrayBuffer>();
 
           if (std::find(array_buffers_.begin(), array_buffers_.end(),
                         array_buffer) != array_buffers_.end()) {

src/inspector/injected-script.cc

@@ -82,7 +82,7 @@ class InjectedScript::ProtocolPromiseHandler {
     }
 
     v8::MaybeLocal<v8::Promise> originalPromise =
-        value->IsPromise() ? v8::Local<v8::Promise>::Cast(value)
+        value->IsPromise() ? value.As<v8::Promise>()
                            : v8::MaybeLocal<v8::Promise>();
     V8InspectorImpl* inspector = session->inspector();
     ProtocolPromiseHandler* handler = new ProtocolPromiseHandler(
@@ -119,9 +119,8 @@ class InjectedScript::ProtocolPromiseHandler {
         info.Data().As<v8::External>()->Value());
     DCHECK(handler);
     v8::Local<v8::Value> value =
-        info.Length() > 0
-            ? info[0]
-            : v8::Local<v8::Value>::Cast(v8::Undefined(info.GetIsolate()));
+        info.Length() > 0 ? info[0]
+                          : v8::Undefined(info.GetIsolate()).As<v8::Value>();
     handler->thenCallback(value);
     delete handler;
   }
@@ -131,9 +130,8 @@ class InjectedScript::ProtocolPromiseHandler {
         info.Data().As<v8::External>()->Value());
     DCHECK(handler);
     v8::Local<v8::Value> value =
-        info.Length() > 0
-            ? info[0]
-            : v8::Local<v8::Value>::Cast(v8::Undefined(info.GetIsolate()));
+        info.Length() > 0 ? info[0]
+                          : v8::Undefined(info.GetIsolate()).As<v8::Value>();
     handler->catchCallback(value);
     delete handler;
   }
@@ -268,8 +266,8 @@ class InjectedScript::ProtocolPromiseHandler {
           toProtocolString(isolate,
                            result->ToDetailString(isolate->GetCurrentContext())
                                .ToLocalChecked());
-      v8::Local<v8::StackTrace> stackTrace = v8::debug::GetDetailedStackTrace(
-          isolate, v8::Local<v8::Object>::Cast(result));
+      v8::Local<v8::StackTrace> stackTrace =
+          v8::debug::GetDetailedStackTrace(isolate, result.As<v8::Object>());
       if (!stackTrace.IsEmpty()) {
         stack = m_inspector->debugger()->createStackTrace(stackTrace);
       }

src/inspector/inspected-context.cc

@@ -70,8 +70,8 @@ InspectedContext::InspectedContext(V8InspectorImpl* inspector,
   if (global->Get(info.context, toV8String(m_inspector->isolate(), "console"))
           .ToLocal(&console) &&
       console->IsObject()) {
-    m_inspector->console()->installMemoryGetter(
-        info.context, v8::Local<v8::Object>::Cast(console));
+    m_inspector->console()->installMemoryGetter(info.context,
+                                                console.As<v8::Object>());
   }
 }
 

src/inspector/v8-console-message.cc

@@ -90,34 +90,33 @@ class V8ValueStringBuilder {
     if (value.IsEmpty()) return true;
     if ((ignoreOptions & IgnoreNull) && value->IsNull()) return true;
     if ((ignoreOptions & IgnoreUndefined) && value->IsUndefined()) return true;
-    if (value->IsString()) return append(v8::Local<v8::String>::Cast(value));
+    if (value->IsString()) return append(value.As<v8::String>());
     if (value->IsStringObject())
-      return append(v8::Local<v8::StringObject>::Cast(value)->ValueOf());
-    if (value->IsBigInt()) return append(v8::Local<v8::BigInt>::Cast(value));
+      return append(value.As<v8::StringObject>()->ValueOf());
+    if (value->IsBigInt()) return append(value.As<v8::BigInt>());
     if (value->IsBigIntObject())
-      return append(v8::Local<v8::BigIntObject>::Cast(value)->ValueOf());
-    if (value->IsSymbol()) return append(v8::Local<v8::Symbol>::Cast(value));
+      return append(value.As<v8::BigIntObject>()->ValueOf());
+    if (value->IsSymbol()) return append(value.As<v8::Symbol>());
     if (value->IsSymbolObject())
-      return append(v8::Local<v8::SymbolObject>::Cast(value)->ValueOf());
+      return append(value.As<v8::SymbolObject>()->ValueOf());
     if (value->IsNumberObject()) {
-      m_builder.append(String16::fromDouble(
-          v8::Local<v8::NumberObject>::Cast(value)->ValueOf(), 6));
+      m_builder.append(
+          String16::fromDouble(value.As<v8::NumberObject>()->ValueOf(), 6));
       return true;
     }
     if (value->IsBooleanObject()) {
-      m_builder.append(v8::Local<v8::BooleanObject>::Cast(value)->ValueOf()
-                           ? "true"
-                           : "false");
+      m_builder.append(value.As<v8::BooleanObject>()->ValueOf() ? "true"
+                                                                : "false");
       return true;
     }
-    if (value->IsArray()) return append(v8::Local<v8::Array>::Cast(value));
+    if (value->IsArray()) return append(value.As<v8::Array>());
     if (value->IsProxy()) {
       m_builder.append("[object Proxy]");
       return true;
     }
     if (value->IsObject() && !value->IsDate() && !value->IsFunction() &&
         !value->IsNativeError() && !value->IsRegExp()) {
-      v8::Local<v8::Object> object = v8::Local<v8::Object>::Cast(value);
+      v8::Local<v8::Object> object = value.As<v8::Object>();
       v8::Local<v8::String> stringValue;
       if (object->ObjectProtoToString(m_context).ToLocal(&stringValue))
         return append(stringValue);
@@ -267,7 +266,7 @@ V8ConsoleMessage::wrapArguments(V8InspectorSessionImpl* session,
     if (m_arguments.size() > 1) {
       v8::Local<v8::Value> secondArgument = m_arguments[1]->Get(isolate);
       if (secondArgument->IsArray()) {
-        columns = v8::Local<v8::Array>::Cast(secondArgument);
+        columns = secondArgument.As<v8::Array>();
       } else if (secondArgument->IsString()) {
         v8::TryCatch tryCatch(isolate);
         v8::Local<v8::Array> array = v8::Array::New(isolate);
@@ -277,8 +276,7 @@ V8ConsoleMessage::wrapArguments(V8InspectorSessionImpl* session,
       }
     }
     std::unique_ptr<protocol::Runtime::RemoteObject> wrapped =
-        session->wrapTable(context, v8::Local<v8::Object>::Cast(value),
-                           columns);
+        session->wrapTable(context, value.As<v8::Object>(), columns);
     inspectedContext = inspector->getContext(contextGroupId, contextId);
     if (!inspectedContext) return nullptr;
     if (wrapped) {

src/inspector/v8-console.cc

@@ -545,7 +545,7 @@ void V8Console::monitorFunctionCallback(
   v8::Local<v8::Function> function;
   if (!helper.firstArgAsFunction().ToLocal(&function)) return;
   v8::Local<v8::Value> name = function->GetName();
-  if (!name->IsString() || !v8::Local<v8::String>::Cast(name)->Length())
+  if (!name->IsString() || !name.As<v8::String>()->Length())
     name = function->GetInferredName();
   String16 functionName =
       toProtocolStringWithTypeCheck(info.GetIsolate(), name);
@@ -844,7 +844,7 @@ V8Console::CommandLineAPIScope::CommandLineAPIScope(
     if (!m_installedMethods->Add(context, name).ToLocal(&m_installedMethods))
       continue;
     if (!m_global
-             ->SetAccessor(context, v8::Local<v8::Name>::Cast(name),
+             ->SetAccessor(context, name.As<v8::Name>(),
                            CommandLineAPIScope::accessorGetterCallback,
                            CommandLineAPIScope::accessorSetterCallback,
                            m_thisReference, v8::DEFAULT, v8::DontEnum,
@@ -869,10 +869,9 @@ V8Console::CommandLineAPIScope::~CommandLineAPIScope() {
     if (!names->Get(m_context, i).ToLocal(&name) || !name->IsName()) continue;
     if (name->IsString()) {
       v8::Local<v8::Value> descriptor;
-      bool success = m_global
-                         ->GetOwnPropertyDescriptor(
-                             m_context, v8::Local<v8::String>::Cast(name))
-                         .ToLocal(&descriptor);
+      bool success =
+          m_global->GetOwnPropertyDescriptor(m_context, name.As<v8::String>())
+              .ToLocal(&descriptor);
       USE(success);
     }
   }

src/inspector/v8-debugger.cc

@@ -657,15 +657,15 @@ v8::MaybeLocal<v8::Value> V8Debugger::getTargetScopes(
   switch (kind) {
     case FUNCTION:
       iterator = v8::debug::ScopeIterator::CreateForFunction(
-          m_isolate, v8::Local<v8::Function>::Cast(value));
+          m_isolate, value.As<v8::Function>());
       break;
     case GENERATOR:
       v8::Local<v8::debug::GeneratorObject> generatorObject =
           v8::debug::GeneratorObject::Cast(value);
       if (!generatorObject->IsSuspended()) return v8::MaybeLocal<v8::Value>();
 
       iterator = v8::debug::ScopeIterator::CreateForGeneratorObject(
-          m_isolate, v8::Local<v8::Object>::Cast(value));
+          m_isolate, value.As<v8::Object>());
       break;
   }
   if (!iterator) return v8::MaybeLocal<v8::Value>();