classes: statics live on the class function object; delete the static attr, deleted-key and name tables (step 3f)

changelog.d/11667-class-builtin-parent-no-class-object.md

@@ -0,0 +1,4 @@
+`Object.getPrototypeOf` of a class, a static `super` parent lookup and a
+static `super[k] = v` no longer create a class function object for a builtin
+parent id (`class E extends Error`): the builtin constructor is the class's
+dynamic parent value, and a class without one is a root.

changelog.d/11667-class-registration-by-identity.md

@@ -0,0 +1,3 @@
+Fixed class registration being keyed by class name: two classes with the same
+name in one module each register their own methods, static methods, accessors
+and constructors under their own class id.

changelog.d/11667-class-static-accessor-entry-convention.md

@@ -0,0 +1,4 @@
+Fixed a class static setter receiving the class instead of the assigned value
+on the generic property path (`C.x = v`, directly, through a variable or on a
+subclass, and `Reflect.set`) and through the reflected setter function
+(`Object.getOwnPropertyDescriptor(C, "x").set`), string- and symbol-keyed.

changelog.d/11667-class-static-attrs-on-keys.md

@@ -0,0 +1,6 @@
+A class static's attributes (`writable`/`enumerable`/`configurable`, set by
+`Object.defineProperty`, `Object.freeze` or a class's intrinsic `name` and
+`length`) are now the key attributes of the class function object's own
+properties, as for any ordinary object, instead of a separate per-class table.
+Deleting such a static and assigning it again yields an ordinary writable,
+enumerable property (the old table kept the deleted key's attributes).

changelog.d/11667-class-static-call-guard-cheap.md

@@ -0,0 +1,4 @@
+Made a compiled `C.m()` static call cheaper: the check that the class still
+holds the declared method is now one shape-word read and compare per class
+the call reads (a direct call costs 6 instructions more than an unguarded
+call, down from 17).

changelog.d/11667-class-static-methods-own-properties.md

@@ -0,0 +1,9 @@
+Fixed class static methods not being ordinary own properties of the class.
+A static method, named or computed, is now a writable, non-enumerable,
+configurable data property of the class function object, whose value is the
+method's own function object: `Object.getOwnPropertyDescriptor(C, "m").value
+=== C.m`, `C.m === Sub.m`, and replacing, redefining (`Object.defineProperty`,
+`Reflect.set`, `Object.assign`) or deleting it is seen by every later call,
+including `C.m()` call sites compiled before the change. A deleted static or
+prototype method no longer reappears on read, and `getOwnPropertyNames` lists
+a class's keys in creation order.

changelog.d/11667-class-static-names-fast-hash.md

@@ -0,0 +1,3 @@
+Class static method and accessor lookups by name hash with ahash instead of
+SipHash, so a static call that misses its site guard probes each class on the
+parent chain faster.

changelog.d/11667-object-intrinsics-standalone.md

@@ -0,0 +1,4 @@
+Made the first use of a class cheaper: `Object` and `Object.prototype` are
+built on their own (about 1M instructions) instead of by building the whole
+global object (about 50M instructions, several hundred builtins); the global
+object adopts the same two objects when it is built.

crates/perry-abi/src/lib.rs

@@ -50,6 +50,17 @@ pub const CLOSURE_INFO_OFFSET: usize = 8;
 pub const CLOSURE_PROPS_OFFSET: usize = 16;
 pub const CLOSURE_HEADER_SIZE: usize = 24;
 
+/// `object::ObjectHeader::parent_class_id`: the object's ShapeId word (LP64
+/// and ILP32 alike; `CLOSURE_SHAPE_OFFSET` is the same word of a closure).
+pub const OBJECT_SHAPE_OFFSET: usize = 4;
+
+/// `object::class_value::StaticCallMemo` (LP64) — the words the emitted
+/// static-call guard reads (`perry-codegen/src/expr/static_method.rs`).
+pub const STATIC_CALL_MEMO_KEY_OFFSET: usize = 0;
+pub const STATIC_CALL_MEMO_C_OFFSET: usize = 8;
+pub const STATIC_CALL_MEMO_OWNER_OFFSET: usize = 16;
+pub const STATIC_CALL_MEMO_VALUE_OFFSET: usize = 24;
+
 /// `gc::GC_TYPE_CLOSURE`: the GcHeader type byte (at payload - 8) that makes a
 /// cell a function object. The kind is this byte, never a payload magic.
 pub const GC_TYPE_CLOSURE: u8 = 4;

crates/perry-codegen/src/codegen/artifact_source_text.rs

@@ -29,6 +29,7 @@ pub(super) fn extend_class_method_source_text(
         .iter()
         .map(|(symbol, _, _)| symbol.clone())
         .collect();
+    let mut entry_sources: Vec<(String, String, bool)> = Vec::new();
     let mut push_defined = |func_id: FuncId, symbol: String| {
         let Some(source) = hir.closure_source_text.get(&func_id) else {
             return;
@@ -103,27 +104,59 @@ pub(super) fn extend_class_method_source_text(
             push_defined(setter.id, symbol);
         }
         for method in &class.static_methods {
-            push_defined(
-                method.id,
-                scoped_static_method_name(module_prefix, class.id, &class.name, &method.name),
-            );
+            let body =
+                scoped_static_method_name(module_prefix, class.id, &class.name, &method.name);
+            // The method's own function object runs `<body>__clo` (string
+            // pool): its toString is the method's source too.
+            if !method.name.starts_with("__perry_static_init_") && llmod.has_function(&body) {
+                if let Some(source) = hir.closure_source_text.get(&method.id) {
+                    entry_sources.push((
+                        format!("{body}__clo"),
+                        super::function_source_header::retained_function_text(
+                            hir,
+                            closures,
+                            method.id,
+                            &source.text,
+                        ),
+                        source.is_non_strict_ordinary,
+                    ));
+                }
+            }
+            push_defined(method.id, body);
         }
         for member in class
             .computed_members
             .iter()
             .filter(|member| member.is_static)
         {
-            push_defined(
-                member.function.id,
-                scoped_static_method_name(
-                    module_prefix,
-                    class.id,
-                    &class.name,
-                    &member.function.name,
-                ),
+            let body = scoped_static_method_name(
+                module_prefix,
+                class.id,
+                &class.name,
+                &member.function.name,
             );
+            // A computed-name static method's function object runs
+            // `<body>__clo` too (string pool).
+            if matches!(member.kind, perry_hir::ClassComputedMemberKind::Method)
+                && llmod.has_function(&body)
+            {
+                if let Some(source) = hir.closure_source_text.get(&member.function.id) {
+                    entry_sources.push((
+                        format!("{body}__clo"),
+                        super::function_source_header::retained_function_text(
+                            hir,
+                            closures,
+                            member.function.id,
+                            &source.text,
+                        ),
+                        source.is_non_strict_ordinary,
+                    ));
+                }
+            }
+            push_defined(member.function.id, body);
         }
     }
+    user_fn_source.extend(entry_sources);
 }
 
 /// Collect retained `Function.prototype.toString` source text for every user

crates/perry-codegen/src/codegen/artifacts.rs

@@ -1004,6 +1004,7 @@ pub(super) fn emit_module_artifacts(c: ModuleArtifactsCtx<'_>) -> Result<()> {
         class_header_image_inits,
         class_ids,
         class_table,
+        &hir.classes,
         &hir.class_display_names,
         &class_source_text,
         &ctor_arity_overrides,