src: add missing qualifiers to env.cc · nodejs/node@a32fa30

js_promise_hooks_[3].Reset(env()->isolate(), resolve);

}

Local<Array> AsyncHooks::GetPromiseHooks(Isolate* isolate) {

std::vector<Local<Value>> values;

Local<Array> AsyncHooks::GetPromiseHooks(Isolate* isolate) const {

v8::LocalVector<Value> values(isolate, js_promise_hooks_.size());

for (size_t i = 0; i < js_promise_hooks_.size(); ++i) {

if (js_promise_hooks_[i].IsEmpty()) {

values.push_back(Undefined(isolate));

values[i] = Undefined(isolate);

} else {

values.push_back(js_promise_hooks_[i].Get(isolate));

values[i] = js_promise_hooks_[i].Get(isolate);

}

}

return Array::New(isolate, values.data(), values.size());

void Environment::UntrackContext(Local<Context> context) {

HandleScope handle_scope(isolate_);

contexts_.erase(std::remove_if(contexts_.begin(),

contexts_.end(),

[&](auto&& el) { return el.IsEmpty(); }),

contexts_.end());

std::erase_if(contexts_, [&](auto&& el) { return el.IsEmpty(); });

for (auto it = contexts_.begin(); it != contexts_.end(); it++) {

Local<Context> saved_context = PersistentToLocal::Weak(isolate_, *it);

if (saved_context == context) {

if (Local<Context> saved_context = PersistentToLocal::Weak(isolate_, *it);

saved_context == context) {

it->Reset();

contexts_.erase(it);

break;

#undef VS

#undef VP

for (size_t i = 0; i < AsyncWrap::PROVIDERS_LENGTH; i++)

info.primitive_values.reserve(info.primitive_values.size() +

AsyncWrap::PROVIDERS_LENGTH);

for (size_t i = 0; i < AsyncWrap::PROVIDERS_LENGTH; i++) {

info.primitive_values.push_back(creator->AddData(async_wrap_provider(i)));

}

uint32_t id = 0;

#define VM(PropertyName) V(PropertyName##_binding_template, ObjectTemplate)

#define V(PropertyName, TypeName) \

void IsolateData::DeserializeProperties(const IsolateDataSerializeInfo* info) {

size_t i = 0;

v8::Isolate::Scope isolate_scope(isolate_);

Isolate::Scope isolate_scope(isolate_);

HandleScope handle_scope(isolate_);

if (per_process::enabled_debug_list.enabled(DebugCategory::MKSNAPSHOT)) {

std::string Environment::GetCwd(const std::string& exec_path) {

char cwd[PATH_MAX_BYTES];

size_t size = PATH_MAX_BYTES;

const int err = uv_cwd(cwd, &size);

if (err == 0) {

if (uv_cwd(cwd, &size) == 0) {

CHECK_GT(size, 0);

return cwd;

}

std::string exec_path;

if (uv_exepath(exec_path_buf, &exec_path_len) == 0) {

exec_path = std::string(exec_path_buf, exec_path_len);

} else if (argv.size() > 0) {

} else if (!argv.empty()) {

exec_path = argv[0];

}

}

void Environment::PrintSyncTrace() const {

if (!trace_sync_io_) return;

if (!trace_sync_io_) [[likely]]

return;

HandleScope handle_scope(isolate());

at_exit_functions_.push_front(ExitCallback{cb, arg});

}

Maybe<bool> Environment::CheckUnsettledTopLevelAwait() {

Maybe<bool> Environment::CheckUnsettledTopLevelAwait() const {

HandleScope scope(isolate_);

Local<Context> ctx = context();

Local<Value> value;

int64_t expiry_ms =

ret.ToLocalChecked()->IntegerValue(env->context()).FromJust();

uv_handle_t* h = reinterpret_cast<uv_handle_t*>(handle);

auto* h = reinterpret_cast<uv_handle_t*>(handle);

if (expiry_ms != 0) {

int64_t duration_ms =

uint64_t now = GetNowUint64();

if (now <= 0xffffffff)

return Integer::NewFromUnsigned(isolate(), static_cast<uint32_t>(now));

else

return Number::New(isolate(), static_cast<double>(now));

return Number::New(isolate(), static_cast<double>(now));

}

void CollectExceptionInfo(Environment* env,

message = uv_strerror(errorno);

}

node::CollectExceptionInfo(this, obj, errorno, err_string,

syscall, message, path, dest);

CollectExceptionInfo(

this, obj, errorno, err_string, syscall, message, path, dest);

}

ImmediateInfo::ImmediateInfo(Isolate* isolate, const SerializeInfo* info)

EmbedderGraph* graph,

void* data) {

MemoryTracker tracker(isolate, graph);

Environment* env = static_cast<Environment*>(data);

auto* env = static_cast<Environment*>(data);

// Start traversing embedder objects from the root Environment object.

tracker.Track(env);

}

size_t Environment::NearHeapLimitCallback(void* data,

size_t current_heap_limit,

size_t initial_heap_limit) {

Environment* env = static_cast<Environment*>(data);

auto* env = static_cast<Environment*>(data);

Debug(env,

DebugCategory::DIAGNOSTICS,

DebugCategory::DIAGNOSTICS,

"Estimated available memory=%" PRIu64 ", "

"estimated overhead=%" PRIu64 "\n",

static_cast<uint64_t>(available),

static_cast<uint64_t>(estimated_overhead));

available,

estimated_overhead);

// This might be hit when the snapshot is being taken in another

// NearHeapLimitCallback invocation.