Skip to content

INT-09: Extend class, descriptor and decorator semantics #33

Open
Open
INT-09: Extend class, descriptor and decorator semantics#33

Description

@ellainng
ellainng
opened on Oct 20, 2026

Part 3 / Broader language

Part of the coordinated source reduction, compiler/browser and independent interpreter program adopted 2026-10-20.

Acceptance criteria

  • Adopt staged class identity, instance attribute lookup, inheritance/MRO, bound methods, descriptors and decorator evaluation contracts before implementation.
  • Specify supported special methods and class-body side effects; defer metaclasses/reflection until their own cases exist.
  • Expand differential and refusal matrices; no blanket Python package compatibility claim follows from basic class support.

Dependencies and readiness

pocket/INT-WEB-01; INT-EXEC-05

Readiness: Ready. The execution-consolidation prerequisites are complete; remaining feature slices still require their own implementation and acceptance.

Plan and delivery

Implementation plan. Issues and Project fields track current state; PRs record implementation and verification.

Use focused branches/PRs, smallest relevant local checks and fresh CI; squash passing dependent work in order. A roadmap update does not authorize a release upload or deployment.

C1 implementation checkpoint — 2026-10-21

C1 covers class bodies, user-class C3 inheritance, instance attributes, initialization and bound methods. Both language selections retain the same complete engine and output-only host boundary. The 39-case class corpus passes in Node and Chromium against CPython or explicit later-stage refusal; dedicated class-console acceptance has 11 passing checks. Existing core/library console and package-install checks remain required. The final PR records current main CI and artifact evidence.

INT-09 delivery checklist

  • C2: data/non-data descriptor precedence and type-level get/set/delete, properties, staticmethod/classmethod and inherited binding, set_name, decorator evaluation/application order and failure side effects.
  • C3: adopt special methods individually, with implicit type lookup, return validation, exception/resource behavior and explicit refusal for unadopted methods/hooks.
  • Close INT-09 only after its adopted C2/C3 matrices pass source, Node/Chromium, memory/cancellation and offline-console checks.

Metaclasses, builtin subclassing, reflective hooks and arbitrary package compatibility retain separate gates. INT-10 async and INT-WASM-01/02/03 remain separately planned; C1 does not authorize an independent-engine alpha publication.

C2 private-name implementation checkpoint — 2026-10-21

All 34 private-name cases compare against CPython in Node and Chromium. The expanded class console has 16 passing checks; existing 39-class and core/library suites remain required. Bytecode 5 and classes-source/1 remain explicit, default core-source/1 remains unchanged, and generated names share the existing identifier/work/cancellation bounds. The final PR records integrated-main CI and artifact evidence.

The descriptor/decorator checkpoint below completes the adopted C2 surface. The next INT-09 step is an explicit matrix for individually adopted C3 special methods. INT-09 remains open and In Progress. Async, the later C/Rust WebAssembly path and alpha publication retain their separate gates.

C2 descriptor/decorator implementation checkpoint — 2026-10-21

All 69 descriptor/decorator source cases pass in Node and Chromium: 66 adopted CPython comparisons and three explicit refusals. The 39 class and 34 private-name matrices still pass. The console now has 23 checks/comparisons, alongside 126 Node tests, the full Python suite and isolated distribution checks. Integrated-main CI and retained artifact evidence are recorded in #84.

The default core-source/1 remains bytecode 4; the explicit classes-source/1 remains bytecode 5. Shared execution/work/recursion/memory limits and the output-only host boundary apply. No new dependency, deployment or package publication accompanies this checkpoint.

INT-09 remains open and In Progress for C3. Metaclasses, builtin subclassing, nested descriptor-valued mutation/notification hooks, property reflection and arbitrary package compatibility retain separate gates. INT-10 async and the later C/Rust WebAssembly implementation remain planned. Public console hosting is tracked separately in #78; the spatial-ui dashboard is tracked in outside-labs/spatial_ui#11.

C3 selected protocol sequence — 2026-10-21

Delivery starts with the contract/reference matrix in #85. Use a shared immutable admission policy and resumable type-level descriptor dispatch through ordinary VM frames. Direct obj.call lookup remains separate from implicit obj() lookup; preserve original arguments, exceptions, source locations, pending roots and resource bounds.

Postpone new, custom attribute hooks, broad arithmetic and metaclasses. Additive protocols keep classes-source/1 and bytecode 5; engine fingerprints identify builds, and incompatible behavior needs an explicit version decision. The first call milestone does not close INT-09 or authorize publication. The existing 39 class, 34 private-name and 69 descriptor matrices remain required.

C3 call implementation checkpoint — 2026-10-21

All 63 special-call source cases pass in Node and Chromium: 55 CPython comparisons and eight explicit future-protocol refusals. Existing 69 descriptor, 39 class and 34 private-name matrices remain green. Final verification includes 139 Node tests, 45 Python tests, 29 class-console checks, 16 core-console checks, eight library-console checks and retained measurements/distribution evidence. The final integrated-main CI and exact-revision artifact verification are recorded in #90.

Call binding retains original temporary positional/keyword values and receivers; callback exceptions and source locations propagate normally. Python-frame recursion, implicit call redirect cycles, work/cancellation, real callback OOM and logical teardown are tested. Native static/bound wrapper unwrapping remains iterative and work-bounded. Additive support retains classes-source/1 and bytecode 5, with the new engine build fingerprint.

INT-09 remains open and In Progress. Next adopt length/truth (len/bool) through the same dispatch foundation and an explicit result/fallback matrix, then formatting and the later protocols above. Async/host integration, later C/Rust WebAssembly, alpha publication and public demo hosting remain separate tasks.

C3 length/truth implementation checkpoint — 2026-10-21

All 93 length/truth cases pass in Node and Chromium: 87 CPython comparisons and six explicit future-protocol refusals. The original 63-call matrix now has 57 comparisons and six refusals; the 39-class matrix promotes its length example to an adopted case. Existing 69 descriptor and 34 private-name cases remain required. Verification includes 152 Node tests, 45 Python tests, 37 class-console checks/comparisons, 16 core-console checks and eight library-console checks. Integrated-main CI and retained exact-revision artifact evidence are recorded in #93.

The default core-source/1 selection and output-only host boundary remain. classes-source/1 stays bytecode 5, with the engine fingerprint identifying this build. INT-09 remains OPEN / In Progress for the next repr/str formatting contract, then indexed objects, iteration/membership and equality/hash. Custom indexing conversion, construction/attribute hooks, broad arithmetic, metaclasses and arbitrary package compatibility retain their gates. Async, later C/Rust WebAssembly, alpha publication and hosting stay separately planned.

Execution consolidation and broader compatibility adopted — 2026-10-21

The continuing objective is broad independent Python 3.14+ language, builtin and useful library/package coverage. Application profile 1 and the first PWA/game are intermediate delivery milestones. General language work remains driven by semantic prerequisites, language-reference gaps and package/application evidence.

Complete the bounded five-PR foundation before widening this milestone's runtime surface:

Keep existing source profiles, bytecode 4/5, source errors, evaluation order, quotas, host grants and console behavior. Intentional accounting changes require an explicit resource-contract revision. Existing delivered checkpoints stay delivered. The consolidation changes execution structure while preserving adopted Python behavior; it adds no new language feature.

The independent #99 compatibility inventory covers ordinary builtins, functions/scopes/defaults/annotations, remaining object protocols, generators/comprehensions, context managers, pattern matching, coroutine/async-generator behavior, t-strings, imports, stdlib APIs and selected pure-Python packages. The pinned CPython 3.14.7 oracle changes only deliberately. #100 tracks separate device/model feasibility with exact assets/devices/budgets still to select.

Consolidation and compatibility roadmap. Preserve the later C/Rust/Wasm path and existing publication gates.

The bounded repr/str slice is delivered below. Continue indexing, iteration/membership and equality/hash through their contract/reference, implementation/ownership and console/integration slices. Each remains unchecked until its own implementation passes. Persistent applications and mobile inference do not gate unrelated language conformance. INT-09 remains open and In Progress.

Execution foundation delivered — 2026-10-22

The eight composed cases retain all recorded instruction/work/arena observations. CI compares adopted and refusal source cases through draining and instruction-boundary execution in Node and Chromium. The console remains a fresh-run application. Multiple parked tasks, persistent callbacks/events, native coroutine/await and additional language protocols remain unimplemented.

Execution contract and compatibility/payload record. This delivery completes the prerequisites, not this parent milestone.

C3 formatting and broad compatibility delivered — 2026-10-22

#129 delivers the versioned #99 inventory (30 feature surfaces, 71 builtin names, 25 finite linked work packages). #130 fixes str(s) identity. #131–133 deliver the bounded contract, owned formatter and offline-console acceptance (#108–110).

Primitive repr/str() and explicit user repr/str now execute through the common machine, with descriptor/MRO selection, actual-string validation and prefix/callback output order. The 67-case matrix separates 58 CPython comparisons and nine future refusals; the console has 51 checks/comparisons and nine Stop/Restart cycles. All 190 Node tests and 28 Node/Chromium drain/step source matrices pass; the eight prior resource baselines remain unchanged. Final main a59f5e8 has verified CI and matching source artifacts.

Keep this parent open and In Progress. #112 indexing is Ready, followed by #113 iteration and #114 equality/hash. Float/container/default-object displays and broader text formatting remain in #127. #111 diagnostic classification is separately Ready. Async #34, Wasm #40–42, hosting #78 and the alpha gate #36 remain separate.

Indexed objects and diagnostic boundaries delivered — 2026-10-22

#134 delivers #111 diagnostic classification. #139–142 deliver #112 through the pinned contract, owned read/conversion, mutation and offline acceptance; #144 explicitly refuses deferred slice comparisons; #146 preserves raw soft-keyword spelling. The source matrix has 373 cases. Current type/MRO lookup, descriptors, strict index results, raw scalar/tuple/slice keys and bounded list/tuple RHS slice mutation use ordinary owned frames.

The indexing matrix has 81 comparisons and 13 future refusals. All 207 Node tests and 32 Node/Chromium drain/step source matrices pass (1,868 executions); eight resource baselines remain unchanged. The class console has 69 comparisons/checks and 15 Stop/Restart cycles. Main 2115df7 has verified CI and matching artifacts. Complete current payload is 372,607 bytes; no speed/device/package claim.

Keep this parent open and In Progress. Next #113 iteration/membership, then #114 equality/hash; #115 numeric work is also Ready. Async #34, later C/Rust/Wasm #40–42, hosting #78 and independent-engine publication #36 retain separate gates. The general Python 3.14+ goal extends beyond applications/games.

Iteration, equality and hashing delivered — 2026-10-22

PRs #151–154 and #156 deliver #113. PRs #161–164 deliver the finite #114 equality/hash contract; #166 corrects deferred list-extension refusals before hook effects. Implicit type/MRO lookup, descriptor binding, raw comparison results, NotImplemented/reflected priority, definition-time hash disabling, stable arena identities and dictionary-key invariants use the owned machine.

The iteration matrix has 104 cases (99 comparisons/five refusals); equality/hash has 103 (97/six). All 245 Node tests pass, including eight unchanged composed resource baselines. The class console has 76 comparisons, 21 acceptance groups and 35 Stop/Restart cycles. The final 40 Node/Chromium drain/step class matrices cover 2,696 executions. Retained reports match source/corpus hashes, zero logical teardown and the current engine fingerprint.

Exact main c5596dc passed CI. The complete payload record records 414,161 bytes across 37 files. The 119 inventory observations distinguish 32 supported, 83 deferred and four host-restricted probes; no Python coverage percentage or speed/device/package claim follows.

Keep INT-09 open and In Progress. Later object construction/attribute/arithmetic protocols, ordering, structural dictionary comparison mutation, tuples containing user instances and bound-method/slice hashing retain finite gates under #116/#123. Next Ready language tasks include #115 numeric APIs, #116 sequence APIs, #118 function binding and #121 synchronous contexts/pattern matching. Async #34, later C/Rust/Wasm #40–42, hosting #78 and publication #36 remain separate.

Numeric construction and operators delivered — 2026-10-22

PRs #177–183 and #185 deliver #115 through the finite contract in docs/interpreter-numeric.md: exact integer division/power/bitwise operations, primitive helpers, real constructors, owned complex values and type-selected conversion/abs/round/index callbacks. #168 improves browser CI setup. Primitive APIs are additive in both source profiles; user callbacks require classes-source/1 and ordinary owned VM frames.

All 278 Node tests pass, including the eight unchanged composed resource observations. The numeric matrix has 180 cases (175 adopted comparisons/five future refusals); the final 44 Node/Chromium drain/step matrices cover 3,416 executions. The installed offline console compares 170 programs, passes 27 further acceptance groups and completes 50 bounded Stop/Restart cycles. All 86 retained reports match implementation/corpus hashes and zero teardown.

Exact main 266c4fc passed CI. The complete payload record records 452,125 bytes across 38 files; a rebuild matches every receipt member, byte/hash and deterministic gzip entry. Inventory probes distinguish 48 supported, 67 deferred and four host-restricted observations, with no overall coverage/performance claim.

Keep INT-09 and async #34 open. #184 tracks remaining numeric methods and complex power/non-finite recovery families; broader values #117, formatting #127 and object/arithmetic/reflected protocols #123 retain separate scopes. Ready language work includes #116 sequence APIs, #117 owned value families, #118 function binding and #121 synchronous contexts/pattern matching. Hosting #78, later C/Rust/Wasm #40–42 and publication #36 retain their gates.

Construction and type protocols delivered — 2026-10-26

Six focused squash merges (#252, #253, #254, #255, #256, #258) deliver #247–251 and the focused #257 correction. All six issues are closed and their Project items are Done.

The finite O3/O4/O5 contract adopts inherited/descriptor-valued new, conditional initialization using the returned instance's actual type, explicit/zero-argument super, lexical class cells, canonical adopted types and tuple type relations. Type-derived metaclasses support selection/conflicts, new/init/call, descriptor precedence and ordinary dictionary namespaces. Required advertised class lookups refuse before hook effects; real type identity and successful actual-type checks remain valid.

Final main is 2c50f2413d1504df0dce05bfc498682aa56c7cd3; all five final-main CI jobs pass. All 387 Node tests pass. The 118-case matrix (106 adopted comparisons/12 refusals) passes across Node/Chromium drain/step: 472 observations and 456 measured zero logical teardown records. Retained reports match final source/corpus/script hashes and the engine fingerprint. Offline acceptance passes 488 program comparisons and 45 groups with 98 Stop/Restart cycles. Eight existing composed resource observations are unchanged.

The construction console builds on final main; its payload record verifies all 38 files and receipt hashes (593,610 bytes). A fresh rebuild matches exactly. This is a construction example payload, not a performance comparison. Reviewed child trees and focused patches were preserved after every actual parent squash and fresh CI; completed branches were removed after checking for open dependents.

#123 and #33 remain open / In Progress. Broader dir/vars/globals/locals/id, custom attribute/advertised-class hooks, ordering, builtin instance layouts, additional metaclass preparation/mapping/special-slot protocols, bound-method/slice hashing and dynamic source admission remain separate finite follow-ups. Async #34 remains Ready for cooperative scheduling, parked ownership, persistent callbacks/events and an adopted awaited capability. No dependency, host authority, publication or deployment change accompanies this batch.

Instance attribute protocols delivered — 2026-10-27

Five focused squash merges (#264–268) deliver #259–263. Main is 2b2414db0523541bf748e7cf3790e42435b61c66, clean and synchronized locally; its tree exactly matches the final accepted PR. All five PRs passed their fresh checks after dependency-order reconciliation, preserving every reviewed child tree and focused patch without rewriting shared history. All five final-main CI jobs pass. Their retained protocol/offline reports match the final source, corpus, driver and engine hashes and zero logical teardown.

The O6/O7/O8 contract adopts actual-type-selected getattribute/getattr, setattr/delattr, native object defaults, and advertised class reads/checks. Descriptor binding, original fallback snapshots, AttributeError-only recovery, tuple error/short-circuit order, super fallback and real-type priority use owned frames and continuations. Deferred metaclass hooks refuse before class-body effects. Core admission, lexical class cells and implicit special lookup retain their existing boundaries.

Validation: 481 Node tests and 13 focused Python tests pass. The 92-case matrix passes all four Node/Chromium drain/step combinations: 368 observations and 352 measured zero logical teardown records. The installed offline console passes 551 program comparisons and 47 acceptance groups with 105 Stop/Restart cycles. Source/corpus/driver hashes and engine receipts match; eight prior composed resource observations are unchanged. All 38 files in the 604,860-byte attribute console payload match a fresh rebuild. No performance or package claim follows.

#123 and #33 remain open / In Progress for namespace/identity reflection (dir/vars/globals/locals/id), ordering, builtin layouts, further metaclass construction/checking hooks, bound-method/slice hashing and dynamic source admission. Async #34 remains Ready for its separate cooperative scheduling, parked ownership, persistent callbacks/events and adopted awaited-capability contract. No dependency, host grant, release, publication or deployment change accompanies this batch.

Custom checking checkpoint — 2026-10-27

Five focused squash merges (#273, #274, #275, #276 and #278) complete #269–272 and #277 under #123. The finite O9/O10/O11 protocol adopts metaclass and ordinary checker instance/subclass hooks, owned descriptor/truth phases, native type defaults and corrected native checking callable reflection. The contract and #123 record exact scope and retained evidence.

Final main is 1725cb0709414a0c7650b5be03bb85fad8ffa369; all five final-main CI jobs pass. All 575 Node tests pass. The 86-case Node/Chromium drain/step matrix has 344 passing observations and 336 measured zero logical teardown records; installed-wheel offline acceptance has 607 program comparisons, 50 groups and 111 Stop/Restart cycles. Source/corpus/driver and complete payload hashes match main. Every reviewed tree and focused diff was preserved after the actual parent squash and fresh checks; completed branches were removed after dependent acceptance.

#33 and #123 remain open / In Progress for the remaining object/class protocols, namespace/identity reflection, ordering, builtin layouts and further metaclass/source-admission work. Async #34 remains Ready and Todo. No dependency, host grant, release, publication or deployment change is included.

Rich ordering delivered — 2026-10-27

Five focused squash merges (#284–288) deliver #279–283 and the finite O12/O13/O14 ordering contract: four rich ordering methods, owned list/tuple lexicographic comparison and raw slice-field equality/ordering. Reflected priority, descriptors, raw results and callback-visible mutation run through the common owned machine.

Final main is c31b590d6b86ee499bc6448c556e2b4ee61c1ce5; all five final-main CI jobs pass. All five child issues are closed / Done. Reviewed trees and focused patches were preserved through every actual parent squash and fresh checks; completed branches are removed.

Validation: 693 Node tests, 456 class/core Node/Chromium drain/step observations with measured zero teardown, 696 offline program comparisons, 53 acceptance groups and 117 Stop/Restart cycles. The eight existing resource observations are unchanged. The 38-file ordered-note payload verifies 612,319 bytes and an identical rebuild; no performance claim follows.

#33 and #123 remain open / In Progress for broader reflection, builtin layouts, further metaclass protocols, bound-method/slice hashing and dynamic source admission. Async #34 remains open / Ready for its separate cooperative scheduling, parked execution, callbacks/events and awaited-capability work. The interpreter remains behind its existing release and deployment gates.

Finite namespace reflection checkpoint — 2026-10-27

Six focused squash merges (#304–308 and #310) complete #299–303 and #309 under #123. The finite O15–O17 contract adopts stable owned identities, optimized-function namespace snapshots and custom vars/dir hooks, with corrected operand/control-flow name order and owned descriptor/iteration phases. #123 records the exact boundaries and evidence.

Main d739ce33e3c4659519c45cd53169947c33c58f1b is clean and synchronized; all five final-main jobs pass. Evidence includes 876 Node tests, 392 Node/Chromium reflection observations with zero logical teardown, 795 offline program comparisons, 57 acceptance groups, 122 Stop/Restart cycles and an identical 38-file final-main rebuild. All six child issues are closed / Done, and completed branches are removed after dependent acceptance.

#33 and #123 remain open for live/default namespace reflection, comprehension namespace rules, integer and builtin instance layouts, further metaclass protocols and dynamic source. Native coroutine/await and host-adapter acceptance remain open under #34. No dependency, host grant or release/deployment change is included.

Directory and generator-expression reflection delivered — 2026-10-27

Five focused squash merges (#316–320) complete #311–315 under #123. The O18–O20 contract adopts generator-expression snapshots with .0 iterator ownership, custom directory length hints with precise binding/call and signed-size errors, and stable owned comparison/truth ordering of arbitrary adopted directory entries.

Main 5c435055b53cd05a97b0e4e640bfd9620addd7a0 is clean and synchronized; all five final-main CI jobs pass. The reviewed child trees and focused patches were preserved after every actual squash and fresh checks. All five child issues are closed / Done, and completed branches were removed after dependent acceptance. #123 records the 952-test Node suite, 656 Node/Chromium reflection observations with zero teardown, installed-wheel offline acceptance and exact 38-file payload evidence.

#33 and #123 remain open for live/default and inlined-comprehension namespace reflection, integer and builtin instance layouts, further metaclass protocols and dynamic source. Native coroutine/await and host-adapter acceptance remain open under #34. No dependency, host grant or release/deployment change is included.

Inlined comprehension reflection accepted — 2026-10-27

The finite O21/O22 contract is delivered by #325–328 and the focused #330 admission correction. Issues #321–324 and #329 are closed / Done. Fresh locals/vars snapshots and directory names now expose enclosing optimized scopes or isolated module/class comprehension namespaces, with nested target masking, captured-cell order and restoration. Deferred lambda-default bindings refuse before application effects; independent lambda bodies remain available.

Main bb5ff0aaa03545f6ef281c84d6bd5d97bbd4f45d is clean and synchronized, and all five final-main CI jobs pass. Reviewed trees and focused diffs survived every actual parent squash and fresh checks; completed branches were removed after dependent acceptance. #123 records the 1,069 Node tests, 1,100 reflection observations, installed-wheel offline acceptance, verified final-main artifact hashes and exact 38-file payload.

#33 and #123 remain open for live/default namespace reflection, unboxed integer identity, builtin layouts, further metaclass protocols and dynamic source. Native coroutine/await and host-adapter acceptance remain open under #34. No dependency, host grant or release/deployment change is included.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    No labels
    No labels

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions