lint

Author: mertcanaltin

src/heap_utils.cc

@@ -7,7 +7,8 @@
 #include "stream_base-inl.h"
 #include "util-inl.h"
 
-// Copied from https://github.com/nodejs/node/blob/b07dc4d19fdbc15b4f76557dc45b3ce3a43ad0c3/src/util.cc#L36-L41.
+// Copied from
+// https://github.com/nodejs/node/blob/b07dc4d19fdbc15b4f76557dc45b3ce3a43ad0c3/src/util.cc#L36-L41.
 #ifdef _WIN32
 #include <io.h>  // _S_IREAD _S_IWRITE
 #ifndef S_IRUSR
@@ -80,10 +81,9 @@ class JSGraph : public EmbedderGraph {
   explicit JSGraph(Isolate* isolate) : isolate_(isolate) {}
 
   Node* V8Node(const Local<v8::Data>& value) override {
-    std::unique_ptr<JSGraphJSNode> n { new JSGraphJSNode(isolate_, value) };
+    std::unique_ptr<JSGraphJSNode> n{new JSGraphJSNode(isolate_, value)};
     auto it = engine_nodes_.find(n.get());
-    if (it != engine_nodes_.end())
-      return *it;
+    if (it != engine_nodes_.end()) return *it;
     engine_nodes_.insert(n.get());
     return AddNode(std::unique_ptr<Node>(n.release()));
   }
@@ -188,13 +188,14 @@ class JSGraph : public EmbedderGraph {
           const char* edge_name = edge.first;
           if (edge_name != nullptr) {
             if (!String::NewFromUtf8(isolate_, edge_name)
-                .ToLocal(&edge_name_value)) {
+                     .ToLocal(&edge_name_value)) {
               return MaybeLocal<Array>();
             }
           } else {
             edge_name_value = Number::New(isolate_, static_cast<double>(j++));
           }
-          if (edge_obj->Set(context, name_string, edge_name_value).IsNothing() ||
+          if (edge_obj->Set(context, name_string, edge_name_value)
+                  .IsNothing() ||
               edge_obj->Set(context, to_string, to_object).IsNothing() ||
               edges.As<Array>()->Set(context, i++, edge_obj).IsNothing()) {
             return MaybeLocal<Array>();
@@ -218,8 +219,7 @@ void BuildEmbedderGraph(const FunctionCallbackInfo<Value>& args) {
   JSGraph graph(env->isolate());
   Environment::BuildEmbedderGraph(env->isolate(), &graph, env);
   Local<Array> ret;
-  if (graph.CreateObject().ToLocal(&ret))
-    args.GetReturnValue().Set(ret);
+  if (graph.CreateObject().ToLocal(&ret)) args.GetReturnValue().Set(ret);
 }
 
 namespace {
@@ -238,13 +238,8 @@ class FileOutputStream : public v8::OutputStream {
     int offset = 0;
     while (offset < size) {
       const uv_buf_t buf = uv_buf_init(data + offset, size - offset);
-      const int num_bytes_written = uv_fs_write(nullptr,
-                                                req_,
-                                                fd_,
-                                                &buf,
-                                                1,
-                                                -1,
-                                                nullptr);
+      const int num_bytes_written =
+          uv_fs_write(nullptr, req_, fd_, &buf, 1, -1, nullptr);
       uv_fs_req_cleanup(req_);
       if (num_bytes_written < 0) {
         status_ = num_bytes_written;
@@ -269,13 +264,12 @@ class HeapSnapshotStream : public AsyncWrap,
                            public StreamBase,
                            public v8::OutputStream {
  public:
-  HeapSnapshotStream(
-      Environment* env,
-      HeapSnapshotPointer&& snapshot,
-      Local<Object> obj) :
-      AsyncWrap(env, obj, AsyncWrap::PROVIDER_HEAPSNAPSHOT),
-      StreamBase(env),
-      snapshot_(std::move(snapshot)) {
+  HeapSnapshotStream(Environment* env,
+                     HeapSnapshotPointer&& snapshot,
+                     Local<Object> obj)
+      : AsyncWrap(env, obj, AsyncWrap::PROVIDER_HEAPSNAPSHOT),
+        StreamBase(env),
+        snapshot_(std::move(snapshot)) {
     MakeWeak();
     StreamBase::AttachToObject(GetObject());
   }
@@ -296,8 +290,7 @@ class HeapSnapshotStream : public AsyncWrap,
     while (len != 0) {
       uv_buf_t buf = EmitAlloc(size);
       ssize_t avail = len;
-      if (static_cast<ssize_t>(buf.len) < avail)
-        avail = buf.len;
+      if (static_cast<ssize_t>(buf.len) < avail) avail = buf.len;
       memcpy(buf.base, data, avail);
       data += avail;
       len -= static_cast<int>(avail);
@@ -312,13 +305,9 @@ class HeapSnapshotStream : public AsyncWrap,
     return 0;
   }
 
-  int ReadStop() override {
-    return 0;
-  }
+  int ReadStop() override { return 0; }
 
-  int DoShutdown(ShutdownWrap* req_wrap) override {
-    UNREACHABLE();
-  }
+  int DoShutdown(ShutdownWrap* req_wrap) override { UNREACHABLE(); }
 
   int DoWrite(WriteWrap* w,
               uv_buf_t* bufs,
@@ -444,8 +433,7 @@ void CreateHeapSnapshotStream(const FunctionCallbackInfo<Value>& args) {
   CHECK(snapshot);
   BaseObjectPtr<AsyncWrap> stream =
       CreateHeapSnapshotStream(env, std::move(snapshot));
-  if (stream)
-    args.GetReturnValue().Set(stream->object());
+  if (stream) args.GetReturnValue().Set(stream->object());
 }
 
 void TriggerHeapSnapshot(const FunctionCallbackInfo<Value>& args) {