v0.10.1: backlog patches across exceptions, slices, ranges

[tamnd]

First slice of the v0.10.1 backlog. These are small isolated ports that piled up across v0.2 through v0.10 and aren't tied to any one panel.

What's in here

• Ellipsis singleton, modeled after the NotImplemented one
• Exception classes that were still missing: warnings (Warning + 10 subclasses), syntax (SyntaxError, IndentationError, TabError, _IncompleteInputError), os (OSError + 15 subclasses with errno mapping), unicode (UnicodeError + 3 variants), group (BaseExceptionGroup, ExceptionGroup), and FloatingPointError
• types.SimpleNamespace with eq/ne via dict comparison
• PyCapsule opaque-pointer container
• PySlice_Unpack / AdjustIndices / GetIndicesEx and slice.indices(length)
• range_iterator split into its own file with length_hint

Notes

• errno aliases on darwin (EAGAIN == EWOULDBLOCK) needed function-init dedup so the first entry wins, matching CPython's ADD_ERRNO order
• range length_hint uses big.Int ceiling division so the hint stays correct for partly consumed iterators
• .golangci.yml exclusion extended to errors/exc_*.go so the PyExc_ singletons stop tripping revive's var-naming check

Test plan

• go test ./... -count=1
• golangci-lint run ./...

[tamnd]

Finished the longobject.c-shaped split. int.go is back to just the struct, type singleton, slot wiring, and constructors. The slot bodies live next to their peers in long_arith / long_bitwise / long_misc, which lines up with the file layout CPython uses.

[tamnd]

Pulled NumberMethods, SequenceMethods, and MappingMethods into their own slots.go. type.go was getting noisy with the bundle structs at the bottom and these are really the protocol panels that hang off the type, not part of the typeobject definition itself. Same arrangement as Include/cpython/object.h.

[tamnd]

list had Append/SetSlice and nothing else. Ported the rest of the listobject.c method panel: count, index, insert, remove, pop, reverse, clear, copy. Sort still needs Timsort and lives in its own task. Also moved listRichCmp out of list.go into list_misc since the slot dispatch table doesn't need to share a file with the slot bodies.

[tamnd]

Ported float repr to match CPython's shortest-roundtrip output. The old code used Go's strconv 'g' -1, which produces the right digits but flips to exponential form at a smaller magnitude than CPython does. Now repr(1e15) gives "1000000000000000.0" instead of "1e+15", and integral floats keep their trailing ".0" via the Py_DTSF_ADD_DOT_0 behaviour. Test panel pins the boundary cases (0, -0.0, 1e15/1e16 hop, 0.0001/0.00001 hop, nan, inf).

[tamnd]

float() never had a string parser, so reaching for float("1.5") from any builtin path would fall through. Ported PyFloat_FromString: whitespace trim, optional sign, inf/infinity/nan tokens (case-insensitive), PEP 515 underscores between digits. The actual digit-to-double bit goes through strconv.ParseFloat since Go ships the same shortest-roundtrip behaviour CPython gets out of _Py_dg_strtod.

[tamnd]

Filled in two of the three remaining 1613 gaps.

tp_traverse was only on dict/list/tuple/set/odict; everything else that can host a cycle had no slot, so the GC would treat them as leaves. Added impls for cell, bound method, classmethod, staticmethod, frame, coroutine wrapper, and the two async-generator awaitables. The frame one is the meaty one — it walks globals/builtins/locals plus the fast/cell/free arrays through the InterpreterFrame interface, then follows the back-chain. Generator/Coroutine/AsyncGenerator themselves stay leaves: in gopy the suspended frame lives on the goroutine, not as an Object field on the generator, so there's no edge to traverse from the gen object's POV.

For the gc_gil piece — that file in CPython is one function, _PyGC_ClearAllFreeLists, which drops cached objects from per-type freelists at the end of a top-gen pass. gopy has no per-type freelists (Go's allocator owns it), so the parity is just a documented no-op. Pulled the inline stub out of collector.go and gave it a real file at gc/gil.go so the absence is explicit instead of buried.

Tests at objects/traverse_more_test.go pin every new traverse impl, including the frame back-chain walk via a fakeInterp stand-in. The gc.garbage resurrection work is still open as the third task.

[tamnd]

1613-P done. The collector now does a proper resurrection pass after finalize_garbage instead of trusting Go's GC to keep refloated objects alive: handleResurrected strips the COLLECTING/UNREACHABLE flags off the post-finalize list, re-runs updateRefs / subtractRefs / moveUnreachable, and splits survivors out into a fresh stillUnreachable head. Anything a finalizer Increfs is back in tracked state by the time Collect returns, mirroring gc.c:1261.

DEBUG_SAVEALL is wired through end-to-end. The module's gc.garbage attribute and state.garbage are now the same *objects.List, registered via a SetGarbage hook that mirrors the existing SetCallbacks pattern. When the bit is set, appendGarbage walks the still-dead list and pushes each object onto gc.garbage; without it the list stays empty (PEP-442-only world has no legacy __del__ path to populate it otherwise). uncollectable stays at zero in gopy because the legacy-finalizer panel is empty by construction.

Tests in gc/garbage_test.go cover: empty by default, populated under SaveAll, the module attribute and the runtime view share storage, finalizer-driven resurrection keeps both cycle members tracked, the resurrected finalizer fires exactly once across two collections, and SaveAll-skipped-when-disabled. Existing cycle/finalize tests still pass; resurrection's new pre-pass leaves them unchanged because no finalizer Increfs.

Spec 1613-N/-O/-P now all show [x] on the v0.10.x remaining-work list. Filed a follow-up to walk every scenario in cpython/Lib/test/test_gc.py and pin the matching gopy assertion so we can claim 100% parity rather than just "the obvious cases pass."

[tamnd]

test_gc.py parity sweep landed in commit 8e32f09. Walked the GCTests panel end to end and shipped a 1:1 Go counterpart for every scenario gopy can execute today, each carrying a // CPython: Lib/test/test_gc.py:LINENUM citation:

• Container-shape cycles: list self-loop, dict self-loop, list+tuple cycle (the one CPython has to close through a list because tuples are immutable).
• Inspection panel: get_referents over list/tuple/dict plus the atom-returns-empty case, is_tracked membership for both atoms and containers, is_finalized across resurrection (the bit must persist when the object refloats).
• Generation accounting: get_count after a fresh allocation, collect_generations promotion from gen0 to gen1 after Collect(0), get_stats panel shape and per-generation collections deltas, freeze / unfreeze round-trip, get_objects(-1) and get_objects(0) visibility before and after a full collect.
• PEP 442 invariants: finalizer fires once even across resurrection, resurrection is transitive (cargo refloats with Lazarus), and a resurrecting cycle must not block reclaim of unrelated cycles in the same Collect. The third one also pins that the resurrected count does not inflate stats[gen].collected.
• bug21435 regression.

Scenarios that hinge on user classes, capsules, the trashcan, or collector reentrancy are pinned as TestParityGapsTracked subtests with an explicit citation and the gating spec/task ID, so the gap is discoverable from go test -v ./gc/... rather than dropped silently. As __build_class__ (#356), exec() (#344), and friends land, those Skip lines flip into real ports.

[tamnd]

WeakSet, WeakValueDictionary, and WeakKeyDictionary now exist as Go types in a new weakref/ package. The shape mirrors Lib/_weakrefset.py and Lib/weakref.py: each container's storage is a map keyed by *objects.Weakref, and a per-container BuiltinFunction acts as the _remove callback that the GC's handle_weakrefs path fires when a referent dies.

TpTraverse on each container visits the side that should keep things alive (strong values for WeakValueDictionary, strong values + weakref keys for WeakKeyDictionary, just the stored weakrefs for WeakSet) but never the weakly-held side, so cycle detection sees the right boundary.

Tests cover the API (add/remove/discard/contains/iter/update/copy/pop on the set side, get/set/del/contains/keys/values/items/update on the dict side) plus the end-to-end gc.Track -> gc.Collect -> _remove path that proves the collector wiring actually fires.

One known leak: each _remove closure captures the container strongly, so an abandoned container won't be reclaimed until every weakref it issued has died. CPython sidesteps this by capturing ref(self) in the closure; matching that needs a TpTraverse-aware closure shape, which I tracked as 1613-S in the spec for a follow-up pass.

[tamnd]

Added objects/memoryview.go for the v0.10 surface: 1-D contiguous unsigned-byte views over bytes / bytearray / another memoryview. Integer indexing returns an int (byte value); slicing returns a new view (aliasing the underlying slice for step==1, copying for stepped slices since the slice is no longer contiguous in the source). The buffer-protocol attributes — format, itemsize, nbytes, readonly, ndim, shape, strides, suboffsets, the contiguity flags, obj — all come back from __getattr__. Equality runs against any bytes-like via a small bytesViewOf helper, and hashing is gated on readonly like CPython.

Writable views and the PEP 3118 multi-format path are still deferred to 1689-B; they need a real buffer slot on Type first. Tests cover the lot (15 cases): wrapping, indexing, both slice shapes, iteration, attributes, equality vs bytes, hash, tobytes/tolist, and the rejection path for non-bytes-like inputs.

[tamnd]

Got class C(...): ... actually working through __build_class__.

The path was longer than I expected. LOAD_BUILD_CLASS now resolves
the builtin from f.Builtins (falling back to f.Globals for the
test case where the builtins dict is the only scope), and the new
vm/build_class.go runs the inner body with the class namespace as
f_locals before handing it to type(name, bases, ns).

To make type(...) actually allocate user instances I added an
IsUser flag (the gopy stand-in for Py_TPFLAGS_HEAPTYPE), an Instance
struct that holds a dict, NewUserType to consume the namespace,
and FunctionType.DescrGet so methods bind through the descriptor
protocol when looked up on an instance.

Three latent bugs in the parser/compiler showed up only once classes
exercised the full path:

• actionAstClassDef was a placeholder, so every class C: ... parsed
  to an empty Module body. Wired up the real implementation in
  action_helpers_gen.go and added the name to the parser-gen excluded
  list.
• argumentsOf didn't unwrap the []any{*ast.Arguments} shape the
  grammar passes through params, so every def f(self, ...): ...
  produced FunctionDef with Args=[] and the body treated parameters
  as globals (LOAD_GLOBAL self instead of LOAD_FAST self). Fixing
  this also fixes plain top-level defs that take arguments.
• LOAD_ATTR's oparg lost the <<1 shift CPython packs in for the
  method bit, so c.foo was looking up Names[0] instead of Names[1].
  Same shift that codegen.c:codegen_addop_name applies.

Also a tiny wrapConst case for *compile.Code so MAKE_FUNCTION sees
an *objects.Code when a const slot points to a nested code object.

Eight end-to-end tests in vm/build_class_test.go cover empty body,
class attributes, instantiation, instance attr set/get, method bind

• call, __init__ with args, single-base inheritance, and the raw
  function returned by C.foo. All green; full suite and lint clean.

[tamnd]

super lands on this branch — super(B, self).method() and super(B, self).__init__(...) work end-to-end through MakeFunction → build_class.

The objects.Super type mirrors superobject: getattr walks the owner's MRO past the named type, the descriptor protocol rebinds super(C) to super(C, owner), and the type call slot dispatches both the one-arg and two-arg forms (zero-arg super() still raises until I wire frame introspection in a follow-up).

Two compile-side bugs surfaced while building the e2e tests and got their own commits up front:

• LOAD_GLOBAL was emitting the raw name index instead of (idx<<1). Worked fine while every function only used a single global; broke the moment super(B, self) needed two distinct globals (the second was decoded as "push NULL plus index 0").
• MAKE_FUNCTION still folded the closure / defaults / annotations bits into its oparg, but the 3.14 vm expects them as separate SET_FUNCTION_ATTRIBUTE ops. Closure tuples were getting stranded on the stack and inner functions hit COPY_FREE_VARS: frame has no closure as soon as anything tried to capture a cell.

Class bodies now stamp __class__ as an implicit cell whenever any method references super (or __class__ itself) — the codegen prologue emits MAKE_CELL, the epilogue copies it into __classcell__, and NewUserType patches the cell with the freshly built class.

Coverage:

• objects/super_test.go — 11 unit tests at the type layer (MRO walk, supercheck, repr, descriptor rebind, kwargs rejection)
• vm/super_test.go — three e2e Python sources: two-arg chain, grandparent reach via MRO, and the canonical super().__init__ chain

Next up: #367 __slots__.

[tamnd]

slots landed in dc9ab25.

NewUserType now reads __slots__ out of the class namespace before walking it for descriptors. Each slot becomes a MemberDescr on the type at a fixed index; the instance carries a parallel slots []Object array and skips the per-instance __dict__ unless __slots__ explicitly lists __dict__ or a base contributes one. Non-slot writes on a __slots__-only class hit the tp_setattro fallthrough and raise AttributeError, matching PyObject_GenericSetAttr when tp_dictoffset == 0.

Validation mirrors type_new_visit_slots/type_new_copy_slots: __slots__ may be a string or a tuple/list of strings, names must be identifiers, and a slot whose name collides with a class-body assignment raises ValueError. __weakref__ is recognised but skipped (no per-instance weakref offset yet). Reading an unset slot raises AttributeError, matching Py_T_OBJECT_EX.

Coverage:

• objects/slots_test.go exercises the descriptor install path directly.
• vm/slots_test.go runs the full class C: __slots__ = (...) source through compile + __build_class__.

[tamnd]

compile() landed in d043a68.

The builtin now wraps the existing parser + compile pipeline: mode picks the parser entry (exec -> file, eval -> expression, single -> single statement), and the produced compile.Code is lifted to objects.Code so callers can hand the result to EvalCode (and to the upcoming eval/exec builtins).

Validation mirrors CPython:

• mode must be one of exec/eval/single. func_type carries the same "requires PyCF_ONLY_AST" rejection wording, since gopy still lacks Python-level AST.
• optimize must be in [-1, 2]; anything else is a ValueError.
• flags is recognised but the only bits that would change behaviour (PyCF_ONLY_AST / PyCF_OPTIMIZED_AST) are rejected for the same reason as func_type. Other future-statement / dont_imply_dedent bits are silently accepted because they don't alter codegen output here yet.
• dont_inherit is parsed for signature parity; gopy has no surrounding compiler-flags context to inherit, so the value is a no-op.

Coverage:

• builtins/compile_test.go covers the three real modes, kwarg routing, missing-arg / wrong-type / unknown-kwarg / out-of-range errors, and the func_type rejection.
• vm/compile_builtin_test.go runs an end-to-end pipeline: compile() -> EvalCode, and confirms the produced code object actually executes.

[tamnd]

eval() and exec() landed in dabbe1a. They share so much shape (the same source coercion, the same globals/locals defaulting, the same evaluator hook) that splitting them across two commits would have been pure noise.

The dispatch goes:

• str source -> parser.ParseString (eval mode for eval(), file mode for exec()) -> compile.Compile -> lift to objects.Code.
• code object source -> passed through.
• both then call the Evaluator hook installed by vm/builtins_hook.go, which grabs the active state.Thread (or allocates a fresh one when there is no running frame, so library callers work) and routes through EvalCode.

Defaulting matches CPython: globals must be a real dict; when omitted (or None), it pulls from the running frame via the existing SetCurrentScope hook. locals defaults to globals when only globals was given, and to the running frame's locals when both are omitted. eval() returns the expression value, exec() returns None on success.

Closure tuples for exec(code, ..., closure=...) are not wired yet: the panel rejects unknown kwargs so any closure= call surfaces a TypeError today instead of silently dropping the closure cells. That can come back as a follow-up if anything in CPython's testsuite reaches for it.

Coverage:

• builtins/eval_test.go exercises the arg routing and validation through a captured evaluator hook (no vm dependency).
• vm/eval_builtin_test.go runs the real pipeline: eval("3*14", g), exec("answer = 6*7\n", g), and eval(compile("21+21","<t>","eval"), g).

Marking #345 and #344 done.

[tamnd]

Picked up #365 next: open() and a minimum-viable File type to back it.

Rather than land the full _io tree (PyFileIO, PyBufferedReader/Writer, PyTextIOWrapper, IOBase) in one shot, I collapsed those layers into a single objects.File for now. It wraps *os.File plus a bufio.Reader for read modes and a bufio.Writer for write/append modes; a binary flag toggles whether read/write trade in bytes or str. Methods (read, readline, write, close, flush, enter, exit, readable, writable) and attributes (name, mode, closed) are exposed via Getattro since the type-method registration plumbing for built-ins isn't wired yet.

builtins/open.go is essentially a Go port of the validator at _pyio.py:75 def open — it walks the mode string against "axrwb+t", rejects duplicates, t+b, multiple direction bits, then translates the validated booleans into the right os.OpenFile flag combo. '+' flips whichever base mode you have to O_RDWR. encoding, errors, and newline are accepted but not honored yet (text mode goes straight through Go's UTF-8).

Tests cover the round-trip (write then reopen-and-read), all six error paths in mode validation, append vs. truncate vs. exclusive, and the iterator/enter/exit contract. Splitting this back into separate raw/buffered/text classes — and adding a real codec layer — stays on the 1689 punchlist.

[tamnd]

On to #364: myreadline.

Parser/myreadline.c is the dispatch layer that sits between the REPL and whichever actual line-editor is loaded. By default it points at PyOS_StdioReadline (no editing, no history, just fgets-until-newline); when the readline extension module imports, it overwrites PyOS_ReadlineFunctionPointer with a GNU readline / libedit shim. That second piece is Modules/readline.c, ~1700 lines of C tied to a specific dependency, and lands as its own port — but the function-pointer mechanism itself is the prerequisite, and that's what this commit covers.

New package myreadline/ keeps the same shape:

• Reader func(stdin, stdout, prompt) (string, error) is the hook signature.
• SetReader(r) swaps in a custom reader (peterh/liner, a cgo bridge, anything else); nil falls back to StdioReadline.
• Readline is the public entry that picks the right path and refuses re-entry the way _PyOS_ReadlineTState does.
• ErrInterrupt distinguishes Ctrl-C from EOF so the REPL can print KeyboardInterrupt and keep prompting.

pythonrun.InteractiveLoop now drives input through myreadline.Readline instead of its private bufio.Reader, and handles the interrupt/EOF distinction. Test coverage installs a fake reader and verifies the loop sees every prompt + acts on every signal.

PS2 continuation is still on the punchlist — it needs the parser to surface an "input incomplete" signal so the loop knows when to keep asking for more lines, which the gopy parser doesn't yet do.