Should we show "Class objects" as objects?

[mmarchini]

• Version: llnode 1.7.0, node v8.11.1
• Platform: OS X (10.13.4)
• Subsystem: findjsobjects, findjsinstances, inspect

Right now if we declare a class (let's say, Lira), and we don't create an instance of that class, v8 findjsobjects will still show us that we have 1 instance of Lira. If we have a class with instances (let's say, Lero), v8 findjsobjects will show us one more instance than we actually have. Example of this behavior below.

I'm not sure how mdb_v8 handles this, but Chrome DevTools snapshots won't count classes as objects. Should we change the current behavior? Or maybe make it clearer when some object is actually a class instead of an instance?

Example:

index.js

class Lero {
 constructor() {
 this.lala = {};
 }
}

class Lira {
 constructor() {
 this.lele = {};
 }
}


const lero = new Lero();

function foo() {
 const lero2 = new Lero();
 boom();
}

foo();

llnode results

 Instances Total Size Name
 ---------- ---------- ----
 1 24 AssertionError
 1 24 AsyncResource
 1 24 FastBuffer
 1 24 Lira
 1 24 Loader
 1 24 ModuleJob
 1 24 ModuleMap
 1 24 Performance
 1 24 PerformanceObserver
 1 24 SafeMap
 1 24 SafePromise
 1 24 SafeSet
 1 24 TextDecoder
 1 24 TextEncoder
 1 24 TickObject
 1 24 URL
 1 24 URLContext
 1 24 URLSearchParams
 1 24 WebAssembly
 1 24 console
 1 32 (Object)
 1 104 ImmediateList
 1 104 Stack
 1 112 Console
 2 48 (anonymous)
 2 48 process
 2 64 ChannelWrap
 2 64 Signal
 2 120 Resolver
 2 128 PerformanceNodeTiming
 2 136 NextTickQueue
 2 200 PerformanceObserverEntryList
 2 208 WriteStream
 2 272 Module
 2 608 ReadableState
 2 640 WritableState
 3 72 NodeError
 3 96 TTY
 3 216 Lero
 3 248 BufferList
 3 280 AsyncHook
 12 384 ContextifyScript
 14 1120 (ArrayBufferView)
 55 3520 NativeModule
 327 10464 (Array)
 642 36248 Object
 6896 53488 (String)
 ---------- ----------
 8009 109504

[bnoordhuis]

Good idea, we could print them as e.g. Class: Foo.

I believe you distinguish a class constructor from a normal constructor function by looking at one of the bits (bit 3?) of its SharedFunctionInfo::compiler_hints field.

[mmarchini]

Maybe we could look at in object properties count? Seems to be zero every time the object is a class and non-zero otherwise.

SharedFunctionInfo::compiler_hints has the IsClassConstructor bit on even on some instances (for example, if a class doesn't implement its own constructor), so it doesn't seem to be an accurate check. There's also the IsConstructor bit in Map::bit_field, but I could'nt get one example where Map::bit_field is not 00000000.

Worst case we could just look at the object's properties and consider it to be a Class if it has a constructor property...

[bnoordhuis]

Maybe we could look at in object properties count? Seems to be zero every time the object is a class and non-zero otherwise.

Is that still true when you do C.x = 1 (where C is a class)?