From 2bbd8a7fb2adaa076dcd8c164e31edecb125a3e0 Mon Sep 17 00:00:00 2001
From: yp9522 <yanpeng51@h-partners.com>
Date: Wed, 14 May 2025 15:15:26 +0800
Subject: [PATCH] SendableDebugInfo

Issue:https://gitee.com/openharmony/arkcompiler_ets_frontend/issues/IC49TP
Signed-off-by: yp9522 <yanpeng51@h-partners.com>
---
 tooling/agent/debugger_impl.cpp       | 26 +++++++++++++++++----
 tooling/backend/debugger_executor.cpp | 33 +++++++++++++++++++++++++++
 tooling/backend/debugger_executor.h   |  2 ++
 3 files changed, 56 insertions(+), 5 deletions(-)

diff --git a/tooling/agent/debugger_impl.cpp b/tooling/agent/debugger_impl.cpp
index a8a80762..4faceebe 100755
--- a/tooling/agent/debugger_impl.cpp
+++ b/tooling/agent/debugger_impl.cpp
@@ -2032,15 +2032,31 @@ std::vector<std::unique_ptr<Scope>> DebuggerImpl::GetClosureScopeChains(const Fr
         thread, DebuggerApi::GetEnv(frameHandler));
     JSMutableHandle<JSTaggedValue> valueHandle = JSMutableHandle<JSTaggedValue>(thread, JSTaggedValue::Hole());
     JSTaggedValue currentEnv = envHandle.GetTaggedValue();
-    if (!currentEnv.IsTaggedArray()) {
-        LOG_DEBUGGER(DEBUG) << "GetClosureScopeChains: currentEnv is invalid";
+    JSMutableHandle<JSTaggedValue> sendableEnvHandle = JSMutableHandle<JSTaggedValue>(
+        thread, DebuggerApi::GetSendableEnv(vm_));
+    JSTaggedValue currentSendableEnv = sendableEnvHandle.GetTaggedValue();
+    if (!currentEnv.IsTaggedArray() && !currentSendableEnv.IsTaggedArray()) {
+        LOG_DEBUGGER(DEBUG) << "GetClosureScopeChains: currentEnv and currentSendableEnv is invalid";
         return closureScopes;
     }
     // check if GetLocalScopeChain has already found and set 'this' value
     bool thisFound = (*thisObj)->HasValue();
     bool closureVarFound = false;
+    bool searchSendableEnv = true;
+    bool closureAdded = false;
+    Local<ObjectRef> closureScopeObj = ObjectRef::New(vm_);
     // currentEnv = currentEnv->parent until currentEnv becomes undefined
-    for (; currentEnv.IsTaggedArray(); currentEnv = LexicalEnv::Cast(currentEnv.GetTaggedObject())->GetParentEnv()) {
+    for (; currentEnv.IsTaggedArray() || searchSendableEnv;
+         currentEnv = LexicalEnv::Cast(currentEnv.GetTaggedObject())->GetParentEnv()) {
+        // add SendableDebugInfo
+        if (!currentEnv.IsTaggedArray()) {
+            searchSendableEnv = false;
+            envHandle = sendableEnvHandle;
+            currentEnv = currentSendableEnv;
+            if (!currentEnv.IsTaggedArray()) {
+                break;
+            }
+        }
         LexicalEnv *lexicalEnv = LexicalEnv::Cast(currentEnv.GetTaggedObject());
         envHandle.Update(currentEnv);
         if (lexicalEnv->GetScopeInfo().IsHole()) {
@@ -2050,7 +2066,6 @@ std::vector<std::unique_ptr<Scope>> DebuggerImpl::GetClosureScopeChains(const Fr
         auto result = JSNativePointer::Cast(lexicalEnv->GetScopeInfo().GetTaggedObject())->GetExternalPointer();
         ScopeDebugInfo *scopeDebugInfo = reinterpret_cast<ScopeDebugInfo *>(result);
         std::unique_ptr<RemoteObject> closure = std::make_unique<RemoteObject>();
-        Local<ObjectRef> closureScopeObj = ObjectRef::New(vm_);
 
         for (const auto &[name, slot] : scopeDebugInfo->scopeInfo) {
             if (IsVariableSkipped(name.c_str())) {
@@ -2082,7 +2097,8 @@ std::vector<std::unique_ptr<Scope>> DebuggerImpl::GetClosureScopeChains(const Fr
             closureScopeObj->DefineProperty(vm_, varName, descriptor);
         }
         // at least one closure variable has been found
-        if (closureVarFound) {
+        if (closureVarFound && !closureAdded) {
+            closureAdded = true;
             closure->SetType(ObjectType::Object)
                 .SetObjectId(runtime_->curObjectId_)
                 .SetClassName(ObjectClassName::Object)
diff --git a/tooling/backend/debugger_executor.cpp b/tooling/backend/debugger_executor.cpp
index c7d2a6c0..1e5642e8 100644
--- a/tooling/backend/debugger_executor.cpp
+++ b/tooling/backend/debugger_executor.cpp
@@ -96,6 +96,10 @@ Local<JSValueRef> DebuggerExecutor::GetValue(const EcmaVM *vm, const FrameHandle
     if (!value.IsEmpty()) {
         return value;
     }
+    value = GetSendableValue(vm, name);
+    if (!value.IsEmpty()) {
+        return value;
+    }
     value = GetModuleValue(vm, frameHandler, name);
     if (!value.IsEmpty()) {
         return value;
@@ -117,6 +121,9 @@ bool DebuggerExecutor::SetValue(const EcmaVM *vm, FrameHandler *frameHandler,
     if (SetLexicalValue(vm, frameHandler, name, value)) {
         return true;
     }
+    if (SetSendableValue(vm, name, value)) {
+        return true;
+    }
     if (SetModuleValue(vm, frameHandler, name, value)) {
         return true;
     }
@@ -176,6 +183,19 @@ Local<JSValueRef> DebuggerExecutor::GetLexicalValue(const EcmaVM *vm, const Fram
     return result;
 }
 
+Local<JSValueRef> DebuggerExecutor::GetSendableValue(const EcmaVM *vm, Local<StringRef> name)
+{
+    Local<JSValueRef> result;
+
+    auto [level, slot] = DebuggerApi::GetSendableSlot(vm, name->ToString(vm));
+    if (level == -1) {
+        return result;
+    }
+
+    result = DebuggerApi::GetSendableProperties(vm, level, slot);
+    return result;
+}
+
 bool DebuggerExecutor::SetLexicalValue(const EcmaVM *vm, const FrameHandler *frameHandler,
                                        Local<StringRef> name, Local<JSValueRef> value)
 {
@@ -190,6 +210,19 @@ bool DebuggerExecutor::SetLexicalValue(const EcmaVM *vm, const FrameHandler *fra
     return true;
 }
 
+bool DebuggerExecutor::SetSendableValue(const EcmaVM *vm, Local<StringRef> name, Local<JSValueRef> value)
+{
+    std::string varName = name->ToString(vm);
+    auto [level, slot] = DebuggerApi::GetSendableSlot(vm, varName);
+    if (level == -1) {
+        return false;
+    }
+
+    DebuggerApi::SetSendableProperties(vm, level, slot, value);
+    vm->GetJsDebuggerManager()->NotifyScopeUpdated(varName, value, Scope::Type::Closure());
+    return true;
+}
+
 Local<JSValueRef> DebuggerExecutor::GetGlobalValue(const EcmaVM *vm, Local<StringRef> name)
 {
     return DebuggerApi::GetGlobalValue(vm, name);
diff --git a/tooling/backend/debugger_executor.h b/tooling/backend/debugger_executor.h
index 5f1f64fb..d06244d6 100644
--- a/tooling/backend/debugger_executor.h
+++ b/tooling/backend/debugger_executor.h
@@ -46,6 +46,7 @@ private:
     static Local<JSValueRef> GetLocalValue(const EcmaVM *vm, const FrameHandler *frameHandler, Local<StringRef> name);
     static Local<JSValueRef> GetLexicalValue(const EcmaVM *vm, const FrameHandler *frameHandler,
                                              Local<StringRef> name);
+    static Local<JSValueRef> GetSendableValue(const EcmaVM *vm, Local<StringRef> name);
     static Local<JSValueRef> GetModuleValue(const EcmaVM *vm, const FrameHandler *frameHandler, Local<StringRef> name);
     static Local<JSValueRef> GetGlobalValue(const EcmaVM *vm, Local<StringRef> name);
 
@@ -53,6 +54,7 @@ private:
                               Local<StringRef> name, Local<JSValueRef> value);
     static bool SetLexicalValue(const EcmaVM *vm, const FrameHandler *frameHandler,
                                 Local<StringRef> name, Local<JSValueRef> value);
+    static bool SetSendableValue(const EcmaVM *vm, Local<StringRef> name, Local<JSValueRef> value);
     static bool SetModuleValue(const EcmaVM *vm, const FrameHandler *frameHandler,
                                Local<StringRef> name, Local<JSValueRef> value);
     static bool SetGlobalValue(const EcmaVM *vm, Local<StringRef> name, Local<JSValueRef> value);
-- 
Gitee