[class] implement inspector support for static private methods

When looking for private members in an object for the inspector,
we check if that object is a class constructor with the a bit
has_static_private_methods set on its SFI. If it
is, we look for any variables in the context locals
with a VariableMode associated with private methods or accessors
and a IsStaticFlag being kStatic.

This patch also filters out static private methods when inspecting
instances.

Design doc: https://docs.google.com/document/d/1N91LObhQexnB0eE7EvGe57HsvNMFX16CaWu-XCTnnmY/edit
See also: https://docs.google.com/document/d/14maU596YbHcWR7XR-_iXM_ANhAAmiuRlJZysM61lqaE/edit

Bug: v8:9839, v8:8330
Change-Id: Idad15349c983898de2ce632c38b0174da10e639d
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1955664Reviewed-by: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Toon Verwaest <verwaest@chromium.org>
Commit-Queue: Joyee Cheung <joyee@igalia.com>
Cr-Commit-Position: refs/heads/master@{#66636}

src/api/api.cc

@@ -9325,6 +9325,34 @@ MaybeLocal<Array> debug::GetInternalProperties(Isolate* v8_isolate,
   return Utils::ToLocal(result);
 }
 
+namespace {
+void CollectPrivateMethodsAndAccessorsFromContext(
+    i::Isolate* isolate, i::Handle<i::Context> context,
+    i::IsStaticFlag is_static_flag, std::vector<Local<Value>>* names_out,
+    std::vector<Local<Value>>* values_out) {
+  i::Handle<i::ScopeInfo> scope_info(context->scope_info(), isolate);
+  int local_count = scope_info->ContextLocalCount();
+  for (int j = 0; j < local_count; ++j) {
+    i::VariableMode mode = scope_info->ContextLocalMode(j);
+    i::IsStaticFlag flag = scope_info->ContextLocalIsStaticFlag(j);
+    if (!i::IsPrivateMethodOrAccessorVariableMode(mode) ||
+        flag != is_static_flag) {
+      continue;
+    }
+
+    i::Handle<i::String> name(scope_info->ContextLocalName(j), isolate);
+    int context_index = scope_info->ContextHeaderLength() + j;
+    i::Handle<i::Object> slot_value(context->get(context_index), isolate);
+    DCHECK_IMPLIES(mode == i::VariableMode::kPrivateMethod,
+                   slot_value->IsJSFunction());
+    DCHECK_IMPLIES(mode != i::VariableMode::kPrivateMethod,
+                   slot_value->IsAccessorPair());
+    names_out->push_back(Utils::ToLocal(name));
+    values_out->push_back(Utils::ToLocal(slot_value));
+  }
+}
+}  // anonymous namespace
+
 bool debug::GetPrivateMembers(Local<Context> context, Local<Object> value,
                               std::vector<Local<Value>>* names_out,
                               std::vector<Local<Value>>* values_out) {
@@ -9345,7 +9373,7 @@ bool debug::GetPrivateMembers(Local<Context> context, Local<Object> value,
                                  i::GetKeysConversion::kConvertToString),
       false);
 
-  // Estimate number of private entries to return in the FixedArray.
+  // Estimate number of private fields and private instance methods/accessors.
   int private_entries_count = 0;
   for (int i = 0; i < keys->length(); ++i) {
     // Exclude the private brand symbols.
@@ -9365,10 +9393,42 @@ bool debug::GetPrivateMembers(Local<Context> context, Local<Object> value,
     }
   }
 
+  // Estimate number of static private methods/accessors for classes.
+  bool has_static_private_methods_or_accessors = false;
+  if (receiver->IsJSFunction()) {
+    i::Handle<i::JSFunction> func(i::JSFunction::cast(*receiver), isolate);
+    i::Handle<i::SharedFunctionInfo> shared(func->shared(), isolate);
+    if (shared->is_class_constructor() &&
+        shared->has_static_private_methods_or_accessors()) {
+      has_static_private_methods_or_accessors = true;
+      i::Handle<i::Context> context(func->context(), isolate);
+      i::Handle<i::ScopeInfo> scope_info(context->scope_info(), isolate);
+      int local_count = scope_info->ContextLocalCount();
+      for (int j = 0; j < local_count; ++j) {
+        i::VariableMode mode = scope_info->ContextLocalMode(j);
+        i::IsStaticFlag is_static_flag =
+            scope_info->ContextLocalIsStaticFlag(j);
+        if (i::IsPrivateMethodOrAccessorVariableMode(mode) &&
+            is_static_flag == i::IsStaticFlag::kStatic) {
+          private_entries_count += local_count;
+          break;
+        }
+      }
+    }
+  }
+
   DCHECK(names_out->empty());
   names_out->reserve(private_entries_count);
   DCHECK(values_out->empty());
   values_out->reserve(private_entries_count);
+
+  if (has_static_private_methods_or_accessors) {
+    i::Handle<i::Context> context(i::JSFunction::cast(*receiver).context(),
+                                  isolate);
+    CollectPrivateMethodsAndAccessorsFromContext(
+        isolate, context, i::IsStaticFlag::kStatic, names_out, values_out);
+  }
+
   for (int i = 0; i < keys->length(); ++i) {
     i::Handle<i::Object> obj_key(keys->get(i), isolate);
     i::Handle<i::Symbol> key(i::Symbol::cast(*obj_key), isolate);
@@ -9380,25 +9440,8 @@ bool debug::GetPrivateMembers(Local<Context> context, Local<Object> value,
     if (key->is_private_brand()) {
       DCHECK(value->IsContext());
       i::Handle<i::Context> context(i::Context::cast(*value), isolate);
-      i::Handle<i::ScopeInfo> scope_info(context->scope_info(), isolate);
-      int local_count = scope_info->ContextLocalCount();
-
-      for (int j = 0; j < local_count; ++j) {
-        i::VariableMode mode = scope_info->ContextLocalMode(j);
-        if (!i::IsPrivateMethodOrAccessorVariableMode(mode)) {
-          continue;
-        }
-
-        i::Handle<i::String> name(scope_info->ContextLocalName(j), isolate);
-        int context_index = scope_info->ContextHeaderLength() + j;
-        i::Handle<i::Object> slot_value(context->get(context_index), isolate);
-        DCHECK_IMPLIES(mode == i::VariableMode::kPrivateMethod,
-                       slot_value->IsJSFunction());
-        DCHECK_IMPLIES(mode != i::VariableMode::kPrivateMethod,
-                       slot_value->IsAccessorPair());
-        names_out->push_back(Utils::ToLocal(name));
-        values_out->push_back(Utils::ToLocal(slot_value));
-      }
+      CollectPrivateMethodsAndAccessorsFromContext(
+          isolate, context, i::IsStaticFlag::kNotStatic, names_out, values_out);
     } else {  // Private fields
       i::Handle<i::String> name(
           i::String::cast(i::Symbol::cast(*key).description()), isolate);

src/ast/ast.h

@@ -2218,6 +2218,14 @@ class FunctionLiteral final : public Expression {
     return RequiresInstanceMembersInitializer::decode(bit_field_);
   }
 
+  void set_has_static_private_methods_or_accessors(bool value) {
+    bit_field_ =
+        HasStaticPrivateMethodsOrAccessorsField::update(bit_field_, value);
+  }
+  bool has_static_private_methods_or_accessors() const {
+    return HasStaticPrivateMethodsOrAccessorsField::decode(bit_field_);
+  }
+
   void set_class_scope_has_private_brand(bool value) {
     bit_field_ = ClassScopeHasPrivateBrandField::update(bit_field_, value);
   }
@@ -2277,7 +2285,9 @@ class FunctionLiteral final : public Expression {
       DontOptimizeReasonField::Next<bool, 1>;
   using ClassScopeHasPrivateBrandField =
       RequiresInstanceMembersInitializer::Next<bool, 1>;
-  using HasBracesField = ClassScopeHasPrivateBrandField::Next<bool, 1>;
+  using HasStaticPrivateMethodsOrAccessorsField =
+      ClassScopeHasPrivateBrandField::Next<bool, 1>;
+  using HasBracesField = HasStaticPrivateMethodsOrAccessorsField::Next<bool, 1>;
   using OneshotIIFEBit = HasBracesField::Next<bool, 1>;
 
   // expected_property_count_ is the sum of instance fields and properties.

src/ast/prettyprinter.cc

@@ -831,6 +831,9 @@ const char* AstPrinter::PrintProgram(FunctionLiteral* program) {
     if (program->class_scope_has_private_brand()) {
       Print(" CLASS SCOPE HAS PRIVATE BRAND\n");
     }
+    if (program->has_static_private_methods_or_accessors()) {
+      Print(" HAS STATIC PRIVATE METHODS\n");
+    }
     PrintParameters(program->scope());
     PrintDeclarations(program->scope()->declarations());
     PrintStatements(program->body());

src/codegen/compiler.cc

@@ -516,6 +516,8 @@ void SetSharedFunctionFlagsFromLiteral(FunctionLiteral* literal,
       literal->class_scope_has_private_brand());
   shared_info.set_is_safe_to_skip_arguments_adaptor(
       literal->SafeToSkipArgumentsAdaptor());
+  shared_info.set_has_static_private_methods_or_accessors(
+      literal->has_static_private_methods_or_accessors());
 }
 
 CompilationJob::Status FinalizeUnoptimizedCompilationJob(

src/diagnostics/objects-printer.cc

@@ -1368,6 +1368,9 @@ void SharedFunctionInfo::SharedFunctionInfoPrint(std::ostream& os) {  // NOLINT
   if (class_scope_has_private_brand()) {
     os << "\n - class_scope_has_private_brand";
   }
+  if (has_static_private_methods_or_accessors()) {
+    os << "\n - has_static_private_methods_or_accessors";
+  }
   os << "\n - kind: " << kind();
   os << "\n - syntax kind: " << syntax_kind();
   if (needs_home_object()) {

src/objects/objects.cc

@@ -5389,6 +5389,10 @@ void SharedFunctionInfo::InitFromFunctionLiteral(
                  IsClassConstructor(lit->kind()));
   shared_info->set_class_scope_has_private_brand(
       lit->class_scope_has_private_brand());
+  DCHECK_IMPLIES(lit->has_static_private_methods_or_accessors(),
+                 IsClassConstructor(lit->kind()));
+  shared_info->set_has_static_private_methods_or_accessors(
+      lit->has_static_private_methods_or_accessors());
 
   shared_info->set_is_toplevel(is_toplevel);
   DCHECK(shared_info->outer_scope_info().IsTheHole());

src/objects/shared-function-info-inl.h

@@ -188,6 +188,10 @@ int SharedFunctionInfo::function_token_position() const {
 BIT_FIELD_ACCESSORS(SharedFunctionInfo, flags2, class_scope_has_private_brand,
                     SharedFunctionInfo::ClassScopeHasPrivateBrandBit)
 
+BIT_FIELD_ACCESSORS(SharedFunctionInfo, flags2,
+                    has_static_private_methods_or_accessors,
+                    SharedFunctionInfo::HasStaticPrivateMethodsOrAccessorsBit)
+
 BIT_FIELD_ACCESSORS(SharedFunctionInfo, flags, syntax_kind,
                     SharedFunctionInfo::FunctionSyntaxKindBits)
 

src/objects/shared-function-info.h

@@ -408,6 +408,7 @@ class SharedFunctionInfo : public HeapObject {
   // True if the outer class scope contains a private brand for
   // private instance methdos.
   DECL_BOOLEAN_ACCESSORS(class_scope_has_private_brand)
+  DECL_BOOLEAN_ACCESSORS(has_static_private_methods_or_accessors)
 
   // Is this function a top-level function (scripts, evals).
   DECL_BOOLEAN_ACCESSORS(is_toplevel)

src/objects/shared-function-info.tq

@@ -43,6 +43,7 @@ bitfield struct SharedFunctionInfoFlags extends uint32 {
 
 bitfield struct SharedFunctionInfoFlags2 extends uint8 {
   class_scope_has_private_brand: bool: 1 bit;
+  has_static_private_methods_or_accessors: bool: 1 bit;
 }
 
 extern class SharedFunctionInfo extends HeapObject {

src/parsing/parse-info.cc

@@ -82,6 +82,8 @@ void ParseInfo::SetFunctionInfo(T function) {
   set_requires_instance_members_initializer(
       function->requires_instance_members_initializer());
   set_class_scope_has_private_brand(function->class_scope_has_private_brand());
+  set_has_static_private_methods_or_accessors(
+      function->has_static_private_methods_or_accessors());
   set_toplevel(function->is_toplevel());
   set_is_oneshot_iife(function->is_oneshot_iife());
 }

src/parsing/parse-info.h

@@ -95,6 +95,9 @@ class V8_EXPORT_PRIVATE ParseInfo {
                 set_requires_instance_members_initializer)
   FLAG_ACCESSOR(kClassScopeHasPrivateBrand, class_scope_has_private_brand,
                 set_class_scope_has_private_brand)
+  FLAG_ACCESSOR(kHasStaticPrivateMethodsOrAccessors,
+                has_static_private_methods_or_accessors,
+                set_has_static_private_methods_or_accessors)
   FLAG_ACCESSOR(kMightAlwaysOpt, might_always_opt, set_might_always_opt)
   FLAG_ACCESSOR(kAllowNativeSyntax, allow_natives_syntax,
                 set_allow_natives_syntax)
@@ -328,7 +331,7 @@ class V8_EXPORT_PRIVATE ParseInfo {
     kAllowHarmonyDynamicImport = 1u << 21,
     kAllowHarmonyImportMeta = 1u << 22,
     kAllowHarmonyOptionalChaining = 1u << 23,
-    kAllowHarmonyPrivateFields = 1u << 24,
+    kHasStaticPrivateMethodsOrAccessors = 1u << 24,
     kAllowHarmonyPrivateMethods = 1u << 25,
     kIsOneshotIIFE = 1u << 26,
     kCollectSourcePositions = 1u << 27,

src/parsing/parser-base.h

@@ -626,6 +626,7 @@ class ParserBase {
           has_name_static_property(false),
           has_static_computed_names(false),
           has_static_class_fields(false),
+          has_static_private_methods(false),
           has_instance_members(false),
           requires_brand(false),
           is_anonymous(false),
@@ -644,6 +645,7 @@ class ParserBase {
     bool has_name_static_property;
     bool has_static_computed_names;
     bool has_static_class_fields;
+    bool has_static_private_methods;
     bool has_instance_members;
     bool requires_brand;
     bool is_anonymous;
@@ -4563,8 +4565,9 @@ typename ParserBase<Impl>::ExpressionT ParserBase<Impl>::ParseClassLiteral(
     if (V8_UNLIKELY(prop_info.is_private)) {
       DCHECK(!is_constructor);
       class_info.requires_brand |= (!is_field && !prop_info.is_static);
-      class_info.has_private_methods |=
-          property_kind == ClassLiteralProperty::METHOD;
+      bool is_method = property_kind == ClassLiteralProperty::METHOD;
+      class_info.has_private_methods |= is_method;
+      class_info.has_static_private_methods |= is_method && prop_info.is_static;
       impl()->DeclarePrivateClassMember(class_scope, prop_info.name, property,
                                         property_kind, prop_info.is_static,
                                         &class_info);

src/parsing/parser.cc

@@ -963,6 +963,8 @@ FunctionLiteral* Parser::DoParseFunction(Isolate* isolate, ParseInfo* info,
         info->requires_instance_members_initializer());
     result->set_class_scope_has_private_brand(
         info->class_scope_has_private_brand());
+    result->set_has_static_private_methods_or_accessors(
+        info->has_static_private_methods_or_accessors());
     if (info->is_oneshot_iife()) {
       result->mark_as_oneshot_iife();
     }
@@ -2977,7 +2979,9 @@ Expression* Parser::RewriteClassLiteral(ClassScope* block_scope,
   if (class_info->requires_brand) {
     class_info->constructor->set_class_scope_has_private_brand(true);
   }
-
+  if (class_info->has_static_private_methods) {
+    class_info->constructor->set_has_static_private_methods_or_accessors(true);
+  }
   ClassLiteral* class_literal = factory()->NewClassLiteral(
       block_scope, class_info->extends, class_info->constructor,
       class_info->public_members, class_info->private_members,

test/cctest/test-debug.cc

@@ -4962,6 +4962,148 @@ TEST(GetPrivateMethodsAndAccessors) {
   }
 }
 
+TEST(GetPrivateStaticMethodsAndAccessors) {
+  i::FLAG_harmony_private_methods = true;
+  LocalContext env;
+  v8::Isolate* v8_isolate = CcTest::isolate();
+  v8::HandleScope scope(v8_isolate);
+  v8::Local<v8::Context> context = env.local();
+
+  v8::Local<v8::String> source = v8_str(
+      "var X = class {\n"
+      "  static #staticMethod() { }\n"
+      "  static get #staticAccessor() { }\n"
+      "  static set #staticAccessor(val) { }\n"
+      "  static get #staticReadOnly() { }\n"
+      "  static set #staticWriteOnly(val) { }\n"
+      "}\n");
+  CompileRun(source);
+  v8::Local<v8::Object> object = v8::Local<v8::Object>::Cast(
+      env->Global()
+          ->Get(context, v8_str(env->GetIsolate(), "X"))
+          .ToLocalChecked());
+  std::vector<v8::Local<v8::Value>> names;
+  std::vector<v8::Local<v8::Value>> values;
+  CHECK(v8::debug::GetPrivateMembers(context, object, &names, &values));
+
+  CHECK_EQ(names.size(), 4);
+  for (int i = 0; i < 4; i++) {
+    v8::Local<v8::Value> name = names[i];
+    v8::Local<v8::Value> value = values[i];
+    CHECK(name->IsString());
+    std::string name_str = FromString(v8_isolate, name.As<v8::String>());
+    if (name_str == "#staticMethod") {
+      CHECK(value->IsFunction());
+    } else {
+      CHECK(v8::debug::AccessorPair::IsAccessorPair(value));
+      v8::Local<v8::debug::AccessorPair> accessors =
+          value.As<v8::debug::AccessorPair>();
+      if (name_str == "#staticAccessor") {
+        CHECK(accessors->getter()->IsFunction());
+        CHECK(accessors->setter()->IsFunction());
+      } else if (name_str == "#staticReadOnly") {
+        CHECK(accessors->getter()->IsFunction());
+        CHECK(accessors->setter()->IsNull());
+      } else {
+        CHECK_EQ(name_str, "#staticWriteOnly");
+        CHECK(accessors->getter()->IsNull());
+        CHECK(accessors->setter()->IsFunction());
+      }
+    }
+  }
+}
+
+TEST(GetPrivateStaticAndInstanceMethodsAndAccessors) {
+  i::FLAG_harmony_private_methods = true;
+  LocalContext env;
+  v8::Isolate* v8_isolate = CcTest::isolate();
+  v8::HandleScope scope(v8_isolate);
+  v8::Local<v8::Context> context = env.local();
+
+  v8::Local<v8::String> source = v8_str(
+      "var X = class {\n"
+      "  static #staticMethod() { }\n"
+      "  static get #staticAccessor() { }\n"
+      "  static set #staticAccessor(val) { }\n"
+      "  static get #staticReadOnly() { }\n"
+      "  static set #staticWriteOnly(val) { }\n"
+      "  #method() { }\n"
+      "  get #accessor() { }\n"
+      "  set #accessor(val) { }\n"
+      "  get #readOnly() { }\n"
+      "  set #writeOnly(val) { }\n"
+      "}\n"
+      "var x = new X()\n");
+  CompileRun(source);
+  v8::Local<v8::Object> object = v8::Local<v8::Object>::Cast(
+      env->Global()
+          ->Get(context, v8_str(env->GetIsolate(), "X"))
+          .ToLocalChecked());
+  std::vector<v8::Local<v8::Value>> names;
+  std::vector<v8::Local<v8::Value>> values;
+  CHECK(v8::debug::GetPrivateMembers(context, object, &names, &values));
+
+  CHECK_EQ(names.size(), 4);
+  for (int i = 0; i < 4; i++) {
+    v8::Local<v8::Value> name = names[i];
+    v8::Local<v8::Value> value = values[i];
+    CHECK(name->IsString());
+    std::string name_str = FromString(v8_isolate, name.As<v8::String>());
+    if (name_str == "#staticMethod") {
+      CHECK(value->IsFunction());
+    } else {
+      CHECK(v8::debug::AccessorPair::IsAccessorPair(value));
+      v8::Local<v8::debug::AccessorPair> accessors =
+          value.As<v8::debug::AccessorPair>();
+      if (name_str == "#staticAccessor") {
+        CHECK(accessors->getter()->IsFunction());
+        CHECK(accessors->setter()->IsFunction());
+      } else if (name_str == "#staticReadOnly") {
+        CHECK(accessors->getter()->IsFunction());
+        CHECK(accessors->setter()->IsNull());
+      } else {
+        CHECK_EQ(name_str, "#staticWriteOnly");
+        CHECK(accessors->getter()->IsNull());
+        CHECK(accessors->setter()->IsFunction());
+      }
+    }
+  }
+
+  names.clear();
+  values.clear();
+  object = v8::Local<v8::Object>::Cast(
+      env->Global()
+          ->Get(context, v8_str(env->GetIsolate(), "x"))
+          .ToLocalChecked());
+  CHECK(v8::debug::GetPrivateMembers(context, object, &names, &values));
+
+  CHECK_EQ(names.size(), 4);
+  for (int i = 0; i < 4; i++) {
+    v8::Local<v8::Value> name = names[i];
+    v8::Local<v8::Value> value = values[i];
+    CHECK(name->IsString());
+    std::string name_str = FromString(v8_isolate, name.As<v8::String>());
+    if (name_str == "#method") {
+      CHECK(value->IsFunction());
+    } else {
+      CHECK(v8::debug::AccessorPair::IsAccessorPair(value));
+      v8::Local<v8::debug::AccessorPair> accessors =
+          value.As<v8::debug::AccessorPair>();
+      if (name_str == "#accessor") {
+        CHECK(accessors->getter()->IsFunction());
+        CHECK(accessors->setter()->IsFunction());
+      } else if (name_str == "#readOnly") {
+        CHECK(accessors->getter()->IsFunction());
+        CHECK(accessors->setter()->IsNull());
+      } else {
+        CHECK_EQ(name_str, "#writeOnly");
+        CHECK(accessors->getter()->IsNull());
+        CHECK(accessors->setter()->IsFunction());
+      }
+    }
+  }
+}
+
 namespace {
 class SetTerminateOnResumeDelegate : public v8::debug::DebugDelegate {
  public:

test/inspector/debugger/class-private-methods-expected.txt

@@ -171,7 +171,7 @@ Evaluating private methods in the base class from the subclass
         columnNumber : 4
         exception : {
             className : SyntaxError
-            description : SyntaxError: Private field '#subclassMethod' must be declared in an enclosing class     at B.fn (<anonymous>:16:7)     at run (<anonymous>:30:5)     at <anonymous>:1:1
+            description : SyntaxError: Private field '#subclassMethod' must be declared in an enclosing class     at B.fn (<anonymous>:20:7)     at run (<anonymous>:34:5)     at <anonymous>:1:1
             objectId : <objectId>
             subtype : error
             type : object
@@ -183,7 +183,7 @@ Evaluating private methods in the base class from the subclass
     }
     result : {
         className : SyntaxError
-        description : SyntaxError: Private field '#subclassMethod' must be declared in an enclosing class     at B.fn (<anonymous>:16:7)     at run (<anonymous>:30:5)     at <anonymous>:1:1
+        description : SyntaxError: Private field '#subclassMethod' must be declared in an enclosing class     at B.fn (<anonymous>:20:7)     at run (<anonymous>:34:5)     at <anonymous>:1:1
         objectId : <objectId>
         subtype : error
         type : object

test/inspector/debugger/class-private-methods-static-expected.txt

+Test static private class methods
+
+Running test: testScopesPaused
+privateProperties on the base class
+[
+    [0] : {
+        name : #writeOnly
+        set : {
+            className : Function
+            description : set #writeOnly(val) { this.#field = val; }
+            objectId : <objectId>
+            type : function
+        }
+    }
+    [1] : {
+        get : {
+            className : Function
+            description : get #readOnly() { return this.#field; }
+            objectId : <objectId>
+            type : function
+        }
+        name : #readOnly
+    }
+    [2] : {
+        get : {
+            className : Function
+            description : get #accessor() { return this.#field; }
+            objectId : <objectId>
+            type : function
+        }
+        name : #accessor
+        set : {
+            className : Function
+            description : set #accessor(val) { this.#field = val; }
+            objectId : <objectId>
+            type : function
+        }
+    }
+    [3] : {
+        name : #inc
+        value : {
+            className : Function
+            description : #inc() { return ++A.#accessor; }
+            objectId : <objectId>
+            type : function
+        }
+    }
+    [4] : {
+        name : #field
+        value : {
+            description : 2
+            type : number
+            value : 2
+        }
+    }
+]
+Evaluating A.#inc();
+{
+    result : {
+        description : 3
+        type : number
+        value : 3
+    }
+}
+Evaluating this.#inc();
+{
+    result : {
+        description : 4
+        type : number
+        value : 4
+    }
+}
+Evaluating ++this.#accessor;
+{
+    result : {
+        description : 5
+        type : number
+        value : 5
+    }
+}
+Evaluating this.#readOnly;
+{
+    result : {
+        description : 5
+        type : number
+        value : 5
+    }
+}
+Evaluating this.#writeOnly = 0; this.#field;
+{
+    result : {
+        description : 0
+        type : number
+        value : 0
+    }
+}
+privateProperties on the subclass
+[
+    [0] : {
+        get : {
+            className : Function
+            description : get #accessor() { return 'subclassAccessor'; }
+            objectId : <objectId>
+            type : function
+        }
+        name : #accessor
+    }
+    [1] : {
+        name : #subclassMethod
+        value : {
+            className : Function
+            description : #subclassMethod() { return B.#accessor; }
+            objectId : <objectId>
+            type : function
+        }
+    }
+]
+Evaluating this.#inc(); from the base class
+{
+    exceptionDetails : {
+        columnNumber : 4
+        exception : {
+            className : SyntaxError
+            description : SyntaxError: Private field '#inc' must be declared in an enclosing class     at Function.test (<anonymous>:24:7)     at run (<anonymous>:28:5)     at <anonymous>:1:1
+            objectId : <objectId>
+            subtype : error
+            type : object
+        }
+        exceptionId : <exceptionId>
+        lineNumber : 0
+        scriptId : <scriptId>
+        text : Uncaught
+    }
+    result : {
+        className : SyntaxError
+        description : SyntaxError: Private field '#inc' must be declared in an enclosing class     at Function.test (<anonymous>:24:7)     at run (<anonymous>:28:5)     at <anonymous>:1:1
+        objectId : <objectId>
+        subtype : error
+        type : object
+    }
+}
+Evaluating this.#subclassMethod();
+{
+    result : {
+        type : string
+        value : subclassAccessor
+    }
+}

test/inspector/debugger/class-private-methods-static-nested-expected.txt

+Test static private class methods
+
+Running test: testScopesPaused
+privateProperties on class A
+[
+    [0] : {
+        name : #method
+        value : {
+            className : Function
+            description : #method() {       debugger;     }
+            objectId : {"injectedScriptId":1,"id":39}
+            type : function
+        }
+    }
+]
+privateProperties on class B
+undefined

test/inspector/debugger/class-private-methods-static-nested.js

+// Copyright 2020 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.
+
+// Flags: --harmony-private-methods
+
+let { session, contextGroup, Protocol } = InspectorTest.start(
+  "Test static private class methods"
+);
+
+const script = `
+function run() {
+  class A {
+    static #method() {
+      debugger;
+    }
+    static test() {
+      class B {
+        static test() { debugger; }
+      }
+      A.#method();  // reference #method so it shows up
+      B.test();
+    }
+  }
+  A.test();
+}`;
+
+contextGroup.addScript(script);
+
+InspectorTest.runAsyncTestSuite([
+  async function testScopesPaused() {
+    Protocol.Debugger.enable();
+
+    // Do not await here, instead oncePaused should be awaited.
+    Protocol.Runtime.evaluate({ expression: 'run()' });
+
+    InspectorTest.log('privateProperties on class A');
+    let {
+      params: { callFrames }
+    } = await Protocol.Debugger.oncePaused(); // inside A.#method()
+    // TODO(joyee): make it possible to desugar the brand check, which requires
+    // the class variable to be saved, even when the static private
+    // methods/accessors are not referenced in the class body.
+    let frame = callFrames[0];
+    let { result } = await Protocol.Runtime.getProperties({
+      objectId: frame.this.objectId
+    });
+    InspectorTest.logObject(result.privateProperties);
+    Protocol.Debugger.resume();
+
+    ({ params: { callFrames } } = await Protocol.Debugger.oncePaused());  // B.test();
+    frame = callFrames[0];
+
+    InspectorTest.log('privateProperties on class B');
+    ({ result } = await Protocol.Runtime.getProperties({
+      objectId: frame.this.objectId
+    }));
+    InspectorTest.logObject(result.privateProperties);
+
+    Protocol.Debugger.resume();
+    Protocol.Debugger.disable();
+  }
+]);

test/inspector/debugger/class-private-methods-static-preview-expected.txt

+Check static private methods in object preview.
+
+Running test: testPrivateMethods
+expression: class { static get #readOnly() { return 1; } }
+{
+    type : string
+    value : class { static get #readOnly() { return 1; } }
+}
+expression: class { static set #writeOnly(val) { } }
+{
+    type : string
+    value : class { static set #writeOnly(val) { } }
+}
+expression: class { static #method() { return 1; } static get #accessor() { } static set #accessor(val) { } }
+{
+    type : string
+    value : class { static #method() { return 1; } static get #accessor() { } static set #accessor(val) { } }
+}
+expression: class extends class { } { static #method() { return 1; } }
+{
+    type : string
+    value : class extends class { } { static #method() { return 1; } }
+}
+expression: class extends class { static #method() { return 1; } } { get #accessor() { } set #accessor(val) { } }
+{
+    type : string
+    value : class extends class { static #method() { return 1; } } { get #accessor() { } set #accessor(val) { } }
+}

test/inspector/debugger/class-private-methods-static-preview.js

+// Copyright 2016 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.
+//
+// Flags: --harmony-private-methods
+
+let {session, contextGroup, Protocol} = InspectorTest.start("Check static private methods in object preview.");
+
+Protocol.Debugger.enable();
+Protocol.Runtime.enable();
+Protocol.Runtime.onConsoleAPICalled(dumpInternalProperties);
+
+contextGroup.setupInjectedScriptEnvironment();
+
+InspectorTest.runAsyncTestSuite([
+  async function testPrivateMethods() {
+    const expressions = [
+        "class { static get #readOnly() { return 1; } }",
+        "class { static set #writeOnly(val) { } }",
+        "class { static #method() { return 1; } static get #accessor() { } static set #accessor(val) { } }",
+        "class extends class { } { static #method() { return 1; } }",
+        "class extends class { static #method() { return 1; } } { get #accessor() { } set #accessor(val) { } }",
+    ];
+    for (const expression of expressions) {
+      InspectorTest.log(`expression: ${expression}`);
+      // Currently the previews are strings of the source code of the classes
+      await Protocol.Runtime.evaluate({
+        expression: `console.table(${expression})`,
+        generatePreview: true
+      });
+    }
+  }
+]);
+
+function dumpInternalProperties(message) {
+  try {
+    InspectorTest.logMessage(message.params.args[0]);
+  } catch {
+    InspectorTest.logMessage(message);
+  }
+}

test/inspector/debugger/class-private-methods-static.js

+// Copyright 2019 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.
+
+// Flags: --harmony-private-methods
+
+let { session, contextGroup, Protocol } = InspectorTest.start(
+  "Test static private class methods"
+);
+
+const script = `
+function run() {
+  class A {
+    static test() {
+      debugger;
+    }
+    static #field = 2;
+    #instanceMethod() { }  // should not show up
+    get #instanceAccessor() { return this.#field; }  // should not show up
+    set #instanceAccessor(val) { this.#field = val; }  // should not show up
+
+    static set #writeOnly(val) { this.#field = val; }
+    static get #readOnly() { return this.#field; }
+    static get #accessor() { return this.#field; }
+    static set #accessor(val) { this.#field = val; }
+    static #inc() { return ++A.#accessor; }
+  };
+  A.test();
+
+  class B extends A {
+    static get #accessor() { return 'subclassAccessor'; }
+    static #subclassMethod() { return B.#accessor; }
+    static test() {
+      debugger;
+    }
+  }
+
+  B.test();
+}`;
+
+contextGroup.addScript(script);
+
+InspectorTest.runAsyncTestSuite([
+  async function testScopesPaused() {
+    Protocol.Debugger.enable();
+
+    // Do not await here, instead oncePaused should be awaited.
+    Protocol.Runtime.evaluate({ expression: 'run()' });
+
+    InspectorTest.log('privateProperties on the base class');
+    let {
+      params: { callFrames }
+    } = await Protocol.Debugger.oncePaused(); // inside A.test()
+    let frame = callFrames[0];
+    let { result } = await Protocol.Runtime.getProperties({
+      objectId: frame.this.objectId
+    });
+    InspectorTest.logMessage(result.privateProperties);
+
+    // TODO(joyee): make it possible to desugar the brand check, which requires
+    // the class variable to be saved, even when the static private
+    // methods/accessors are not referenced in the class body.
+    InspectorTest.log('Evaluating A.#inc();');
+    ({ result } = await Protocol.Debugger.evaluateOnCallFrame({
+      expression: 'A.#inc();',
+      callFrameId: callFrames[0].callFrameId
+    }));
+    InspectorTest.logObject(result);
+
+    InspectorTest.log('Evaluating this.#inc();');
+    ({ result } = await Protocol.Debugger.evaluateOnCallFrame({
+      expression: 'this.#inc();',
+      callFrameId: callFrames[0].callFrameId
+    }));
+    InspectorTest.logObject(result);
+
+    InspectorTest.log('Evaluating ++this.#accessor;');
+    ({ result } = await Protocol.Debugger.evaluateOnCallFrame({
+      expression: '++this.#accessor;',
+      callFrameId: callFrames[0].callFrameId
+    }));
+    InspectorTest.logObject(result);
+
+    InspectorTest.log('Evaluating this.#readOnly;');
+    ({ result } = await Protocol.Debugger.evaluateOnCallFrame({
+      expression: 'this.#readOnly;',
+      callFrameId: callFrames[0].callFrameId
+    }));
+    InspectorTest.logObject(result);
+
+    InspectorTest.log('Evaluating this.#writeOnly = 0; this.#field;');
+    ({ result } = await Protocol.Debugger.evaluateOnCallFrame({
+      expression: 'this.#writeOnly = 0; this.#field;',
+      callFrameId: callFrames[0].callFrameId
+    }));
+    InspectorTest.logObject(result);
+
+    Protocol.Debugger.resume();
+    ({ params: { callFrames } } = await Protocol.Debugger.oncePaused());  // B.test();
+    frame = callFrames[0];
+
+    InspectorTest.log('privateProperties on the subclass');
+    ({ result } = await Protocol.Runtime.getProperties({
+      objectId: frame.this.objectId
+    }));
+    InspectorTest.logMessage(result.privateProperties);
+
+    InspectorTest.log('Evaluating this.#inc(); from the base class');
+    ({ result } = await Protocol.Debugger.evaluateOnCallFrame({
+      expression: 'this.#inc();',
+      callFrameId: callFrames[0].callFrameId
+    }));
+    InspectorTest.logMessage(result);
+
+    InspectorTest.log('Evaluating this.#subclassMethod();');
+    ({ result } = await Protocol.Debugger.evaluateOnCallFrame({
+      expression: 'this.#subclassMethod();',
+      callFrameId: callFrames[0].callFrameId
+    }));
+    InspectorTest.logMessage(result);
+
+    Protocol.Debugger.resume();
+    Protocol.Debugger.disable();
+  }
+]);

test/inspector/debugger/class-private-methods.js

@@ -13,6 +13,10 @@ function run() {
   class A {
     #field = 2;
 
+    static #staticMethod() {}  // should not show up
+    static get #staticAccessor() { }  // should not show up
+    static set #staticAccessor(val) { }  // should not show up
+
     #inc() { this.#field++; return this.#field; }
 
     set #writeOnly(val) { this.#field = val; }