Modules and imports test panel

.gitignore

@@ -31,3 +31,13 @@ TECHNICAL_BRIEF.md
 /compare-baseline
 Tools/bytecodes_gen/bytecodes_gen
 /bytecodes_gen
+
+# test_zipimport scratch artifacts
+junk*.zip
+junk*/
+
+ziptestmodule
+ziptestmodule.py
+
+# test_module_with_large_stack writes this into the cwd
+longlist.py

builtins/compile.go

@@ -109,7 +109,7 @@ func parseCompileArgs(args []objects.Object, kwargs map[string]objects.Object) (
 			return compileArgs{}, err
 		}
 	}
-	filename, err := stringArg(bound[1], "filename")
+	filename, err := compileFilenameArg(bound[1])
 	if err != nil {
 		return compileArgs{}, err
 	}
@@ -150,6 +150,31 @@ func parseCompileArgs(args []objects.Object, kwargs map[string]objects.Object) (
 	}, nil
 }
 
+// compileFilenameArg decodes the filename argument. compile() runs it
+// through PyUnicode_FSDecoder, which accepts str, bytes, or any
+// os.PathLike (pathlib.Path) by invoking __fspath__. importlib's source
+// loaders pass a pathlib.Path here, so a bare str check is too strict.
+//
+// CPython: Python/bltinmodule.c builtin_compile (filename: object,
+//
+//	PyUnicode_FSDecoder) and Objects/unicodeobject.c PyOS_FSPath
+func compileFilenameArg(o objects.Object) (string, error) {
+	switch v := o.(type) {
+	case *objects.Unicode:
+		return v.Value(), nil
+	case *objects.Bytes:
+		return string(v.Bytes()), nil
+	}
+	if fspath, err := objects.GetAttr(o, objects.NewStr("__fspath__")); err == nil {
+		result, callErr := objects.CallNoArgs(fspath)
+		if callErr != nil {
+			return "", callErr
+		}
+		return compileFilenameArg(result)
+	}
+	return "", fmt.Errorf("TypeError: compile() filename must be str, bytes or os.PathLike, not %s", o.Type().Name)
+}
+
 // compileSourceArg accepts the first positional argument to compile().
 // str routes through ParseString. bytes / bytearray route through
 // ParseBytes so the PEP 263 coding cookie controls the decode. AST

builtins/eval.go

@@ -329,3 +329,23 @@ func runCode(code *objects.Code, globals, locals, closure objects.Object) (objec
 	}
 	return currentEvaluator(code, globals, locals, closure)
 }
+
+// RunInFreshNamespace compiles and runs source in a brand-new __main__
+// namespace and returns PyRun_SimpleStringFlags's result code: 0 when the
+// code runs to completion, -1 when it raises. It backs the subinterpreter
+// test entries (_testcapi.run_in_subinterp and
+// _testinternalcapi.run_in_subinterp_with_config). Every gopy extension is
+// a Go builtin compiled into the runtime (multi-phase by construction), so
+// importing one inside a subinterpreter behaves exactly like a fresh-
+// namespace exec in the current process; the only observable result the
+// callers read is the integer status.
+//
+// CPython: Python/pythonrun.c:592 PyRun_SimpleStringFlags
+func RunInFreshNamespace(source string) int {
+	ns := objects.NewDict()
+	_ = ns.SetItem(objects.NewStr("__name__"), objects.NewStr("__main__"))
+	if _, err := Exec([]objects.Object{objects.NewStr(source), ns}, nil); err != nil {
+		return -1
+	}
+	return 0
+}

builtins/import.go

@@ -20,15 +20,22 @@ import (
 )
 
 // Importer resolves a module by name, with pkgname as the anchor for
-// relative imports and level as the dot-count. fromlist is empty for
-// `import a.b.c` and non-empty for `from a.b import c, d`. The hook
-// returns the resolved module along with the same chain CPython hands
-// back: when fromlist is empty the caller wants the top-level package,
-// when fromlist is non-empty the caller wants the deepest module so
+// relative imports and level as the dot-count. fromlist is the raw
+// object the caller passed (None for `import a.b.c`, a sequence for
+// `from a.b import c, d`); it is handed to _handle_fromlist unchanged,
+// so a non-str entry surfaces as the TypeError _handle_fromlist raises
+// rather than an early gopy-only rejection, and an arbitrary iterable
+// is iterated the same way CPython iterates it. globals is the dict the
+// caller handed to __import__ (or nil); the live importlib re-derives
+// the package anchor from it via _calc___package__, so it must be the
+// caller's explicit globals, not the running frame's. The hook returns
+// the resolved module along with the same chain CPython hands back:
+// when fromlist is empty the caller wants the top-level package, when
+// fromlist is non-empty the caller wants the deepest module so
 // IMPORT_FROM can grab attributes off it.
 //
 // CPython: Python/import.c:1561 PyImport_ImportModuleLevelObject
-type Importer func(name, pkgname string, level int, fromlist []string) (objects.Object, error)
+type Importer func(name, pkgname string, level int, fromlist objects.Object, globals objects.Object) (objects.Object, error)
 
 var currentImporter Importer
 
@@ -73,13 +80,13 @@ func Import(args []objects.Object, kwargs map[string]objects.Object) (objects.Ob
 		}
 	}
 	pkgname := pkgnameFromGlobals(parsed.globals)
-	return currentImporter(parsed.name, pkgname, parsed.level, parsed.fromlist)
+	return currentImporter(parsed.name, pkgname, parsed.level, parsed.fromlist, parsed.globals)
 }
 
 type importArgs struct {
 	name     string
 	globals  objects.Object
-	fromlist []string
+	fromlist objects.Object
 	level    int
 }
 
@@ -130,9 +137,15 @@ func parseImportArgs(args []objects.Object, kwargs map[string]objects.Object) (i
 			return importArgs{}, fmt.Errorf("ValueError: level must be >= 0")
 		}
 	}
-	fromlist, err := fromlistArg(bound[3])
-	if err != nil {
-		return importArgs{}, err
+	// fromlist reaches the import machinery untouched. CPython's
+	// builtin___import___impl performs no type or element check; an empty
+	// tuple stands in for a missing argument, and _handle_fromlist raises
+	// the TypeError for any non-str entry or iterates a custom iterable.
+	//
+	// CPython: Python/bltinmodule.c:259 builtin___import___impl
+	fromlist := bound[3]
+	if fromlist == nil {
+		fromlist = objects.NewTuple(nil)
 	}
 	return importArgs{
 		name:     name,
@@ -142,42 +155,6 @@ func parseImportArgs(args []objects.Object, kwargs map[string]objects.Object) (i
 	}, nil
 }
 
-// fromlistArg unpacks the fromlist argument into a flat []string.
-// None and missing both mean "empty"; a tuple or list is iterated; any
-// other type is a TypeError. The element check matches CPython's
-// import.c which rejects non-str entries before lookup.
-//
-// CPython: Python/import.c:1726 import_from
-func fromlistArg(o objects.Object) ([]string, error) {
-	if o == nil || objects.IsNone(o) {
-		return nil, nil
-	}
-	var raw []objects.Object
-	switch v := o.(type) {
-	case *objects.Tuple:
-		raw = make([]objects.Object, v.Len())
-		for i := range raw {
-			raw[i] = v.Item(i)
-		}
-	case *objects.List:
-		raw = make([]objects.Object, v.Len())
-		for i := range raw {
-			raw[i] = v.Item(i)
-		}
-	default:
-		return nil, fmt.Errorf("TypeError: fromlist must be a tuple or list")
-	}
-	out := make([]string, 0, len(raw))
-	for _, item := range raw {
-		s, err := stringArg(item, "fromlist item")
-		if err != nil {
-			return nil, err
-		}
-		out = append(out, s)
-	}
-	return out, nil
-}
-
 // stringArg coerces o to a Go string, raising TypeError when o isn't a
 // Python str. The label is the argument name used in the error.
 func stringArg(o objects.Object, label string) (string, error) {

builtins/import_test.go

@@ -15,17 +15,40 @@ type importCall struct {
 	fromlist []string
 }
 
+// fromlistStrings flattens the raw fromlist object the hook now
+// receives into the []string the assertions below compare against. It
+// mirrors how _handle_fromlist iterates the object, stopping at the
+// first non-str entry (none of these tests pass one).
+func fromlistStrings(o objects.Object) []string {
+	var out []string
+	switch v := o.(type) {
+	case *objects.Tuple:
+		for i := 0; i < v.Len(); i++ {
+			if u, ok := v.Item(i).(*objects.Unicode); ok {
+				out = append(out, u.Value())
+			}
+		}
+	case *objects.List:
+		for i := 0; i < v.Len(); i++ {
+			if u, ok := v.Item(i).(*objects.Unicode); ok {
+				out = append(out, u.Value())
+			}
+		}
+	}
+	return out
+}
+
 func captureImporter(t *testing.T, mod objects.Object, returnErr error) *importCall {
 	t.Helper()
 	prev := currentImporter
 	t.Cleanup(func() { SetImporter(prev) })
 
 	got := &importCall{}
-	SetImporter(func(name, pkgname string, level int, fromlist []string) (objects.Object, error) {
+	SetImporter(func(name, pkgname string, level int, fromlist objects.Object, _ objects.Object) (objects.Object, error) {
 		got.name = name
 		got.pkgname = pkgname
 		got.level = level
-		got.fromlist = fromlist
+		got.fromlist = fromlistStrings(fromlist)
 		return mod, returnErr
 	})
 	return got
@@ -198,16 +221,26 @@ func TestImportNegativeLevel(t *testing.T) {
 	}
 }
 
-func TestImportFromlistRejectsString(t *testing.T) {
-	captureImporter(t, nil, nil)
-	_, err := Import([]objects.Object{
+func TestImportFromlistPassesThroughRawObject(t *testing.T) {
+	// CPython's builtin___import__ never type-checks fromlist; it hands the
+	// object straight to _handle_fromlist, which iterates it. A str is a
+	// valid (if unusual) fromlist, so __import__ must not reject it early.
+	mod := objects.NewModule("a")
+	got := captureImporter(t, mod, nil)
+	out, err := Import([]objects.Object{
 		objects.NewStr("a"),
 		objects.None(),
 		objects.None(),
-		objects.NewStr("notalist"),
+		objects.NewStr("xy"),
 	}, nil)
-	if err == nil || !strings.Contains(err.Error(), "fromlist must be a tuple or list") {
-		t.Fatalf("__import__: err=%v, want fromlist TypeError", err)
+	if err != nil {
+		t.Fatalf("__import__: %v", err)
+	}
+	if out != mod {
+		t.Fatalf("__import__ returned %v, want %v", out, mod)
+	}
+	if got.name != "a" {
+		t.Fatalf("hook name = %q, want a", got.name)
 	}
 }
 

builtins/init.go

@@ -23,6 +23,13 @@ import (
 
 var wireOnce sync.Once
 
+// DefaultImport holds the interpreter's original __import__ builtin so the
+// IMPORT_NAME fast path can recognize it by identity even after user code
+// rebinds builtins.__import__.
+//
+// CPython: pycore_interp.h interp->imports.import_func
+var DefaultImport objects.Object
+
 // Init constructs the builtins dict and stamps the v0.6 surface into
 // it: None / True / False / NotImplemented as named constants, and
 // print as the single callable. defaultFile is the io.Writer the
@@ -151,6 +158,13 @@ func Init(defaultFile io.Writer) (*objects.Dict, error) {
 	if err := setBuiltin(dict, "__import__", importFn); err != nil {
 		return nil, err
 	}
+	// Capture the interpreter's original __import__ so the IMPORT_NAME fast
+	// path can compare against it by identity. Re-reading the builtins
+	// module is wrong: a test that swaps builtins.__import__ would make the
+	// swapped callable compare equal to "the default" and never get called.
+	//
+	// CPython: pycore_interp.h interp->imports.import_func (captured at init)
+	DefaultImport = importFn
 
 	// breakpoint() forwards to sys.breakpointhook. Register the builtin
 	// here and hand the default hook to sys so sys.breakpointhook and