// was enabled, the imports list may contain a fake "C" package.
func (pkg *Package) Imports() []*Package { return pkg.imports }

// SetImports sets the list of explicitly imported packages to list.
// It is the caller's responsibility to make sure list elements are unique.
func (pkg *Package) SetImports(list []*Package) { pkg.imports = list }

func (pkg *Package) String() string {
	return fmt.Sprintf("package %s (%q)", pkg.name, pkg.path)

// was enabled, the imports list may contain a fake "C" package.
func (pkg *Package) Imports() []*Package { return pkg.imports }

// SetImports sets the list of explicitly imported packages to list.
// It is the caller's responsibility to make sure list elements are unique.
func (pkg *Package) SetImports(list []*Package) { pkg.imports = list }

func (pkg *Package) String() string {
	return fmt.Sprintf("package %s (%q)", pkg.name, pkg.path)

	for _, imp := range pr.pkgs {
		if imp != nil && imp != pkg {
			imps = append(imps, imp)
		}
	}
	slices.SortFunc(imps, func(a, b *types.Package) int {
		return strings.Compare(a.Path(), b.Path())
	})
	pkg.SetImports(imps)

	pkg.MarkComplete()
	return pkg
}

// A reader holds the state for reading a single unified IR element
// within a package.
type reader struct {
	pkgbits.Decoder

	p *pkgReader

	// record all referenced packages as imports
	list := append(([]*types.Package)(nil), pkgList[1:]...)
	slices.SortFunc(list, func(a, b *types.Package) int {
		return strings.Compare(a.Path(), b.Path())
	})
	localpkg.SetImports(list)

	// package was imported completely and without errors
	localpkg.MarkComplete()
	return localpkg, nil
}

type setConstraintArgs struct {
	t          *types.TypeParam
	constraint types.Type

pkg go/types, method (*Package) MarkComplete()
pkg go/types, method (*Package) Name() string
pkg go/types, method (*Package) Path() string
pkg go/types, method (*Package) Scope() *Scope
pkg go/types, method (*Package) SetImports([]*Package)
pkg go/types, method (*Package) String() string
pkg go/types, method (*PkgName) Exported() bool
pkg go/types, method (*PkgName) Id() string
pkg go/types, method (*PkgName) Imported() *Package

                + "    " + renderTestCases() + "\n"
                + "}");
    }

    private String renderImports() {
        StringBuilder sb = new StringBuilder();
        for (String importModule : getImports()) {
            sb.append("import ").append(importModule).append('\n');
        }
        for (String importModule : getTestableImports()) {
            sb.append("@testable import ").append(importModule).append('\n');

        return ShellScript.cmdToVarargLiterals(testExecutable.commandLine)
    }

    interface Snippets {
        abstract String getBody()

        abstract String getImports()
    }

    interface SnippetsFactory {
        abstract Snippets newSnippets(ExternalProcessFixture fixture)

        abstract String getSummary()
    }

    interface PrintProcessOutput {

        AstUtils.filterAndTransformStatements(source, transformer);

        // Filter imported classes which are not available yet

        Iterator<ImportNode> iter = source.getAST().getImports().iterator();
        while (iter.hasNext()) {
            ImportNode importedClass = iter.next();
            if (!AstUtils.isVisible(source, importedClass.getClassName())) {
                try {

        this.constituents = constituents;
    }

    public RealmType getType() {
        return type;
    }

    public ClassLoader getParent() {
        return parent;
    }

    public List<String> getImports() {
        return getParentImports();
    }

    public List<String> getParentImports() {
        return parentImports;
    }

    public Map<String, ClassLoader> getForeignImports() {

     */
    ClassLoader getParent();

    /**
     * @deprecated Use {@link #getParentImports()} instead.
     * @return imports
     */
    @Deprecated
    List<String> getImports();

    /**
     * Gets the packages/types to import from the parent realm.
     *
     * @return The modifiable list of packages/types to import from the parent realm, never {@code null}.
     */