goscript 0.0.28 → 0.0.30

package/gs/io/fs/fs.ts

@@ -0,0 +1,359 @@
+import * as $ from "@goscript/builtin/builtin.js";
+
+import * as time from "@goscript/time/index.js"
+
+import * as utf8 from "@goscript/unicode/utf8/index.js"
+
+import * as oserror from "@goscript/internal/oserror/index.js"
+
+export type FS = null | {
+	// Open opens the named file.
+	// [File.Close] must be called to release any associated resources.
+	//
+	// When Open returns an error, it should be of type *PathError
+	// with the Op field set to "open", the Path field set to name,
+	// and the Err field describing the problem.
+	//
+	// Open should reject attempts to open names that do not satisfy
+	// ValidPath(name), returning a *PathError with Err set to
+	// ErrInvalid or ErrNotExist.
+	//
+	// Path names passed to open are UTF-8-encoded,
+	// unrooted, slash-separated sequences of path elements, like "x/y/z".
+	// Path names must not contain an element that is "." or ".." or the empty string,
+	// except for the special case that the name "." may be used for the root directory.
+	// Paths must not start or end with a slash: "/x" and "x/" are invalid.
+	//
+	// Note that paths are slash-separated on all systems, even Windows.
+	// Paths containing other characters such as backslash and colon
+	// are accepted as valid, but those characters must never be
+	// interpreted by an [FS] implementation as path element separators.
+	Open(name: string): [File, $.GoError]
+}
+
+$.registerInterfaceType(
+  'FS',
+  null, // Zero value for interface is null
+  [{ name: "Open", args: [{ name: "name", type: { kind: $.TypeKind.Basic, name: "string" } }], returns: [{ type: "File" }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }]
+);
+
+// ValidPath reports whether the given path name
+// is valid for use in a call to Open.
+//
+// Path names passed to open are UTF-8-encoded,
+// unrooted, slash-separated sequences of path elements, like "x/y/z".
+// Path names must not contain an element that is "." or ".." or the empty string,
+// except for the special case that the name "." may be used for the root directory.
+// Paths must not start or end with a slash: "/x" and "x/" are invalid.
+//
+// Note that paths are slash-separated on all systems, even Windows.
+// Paths containing other characters such as backslash and colon
+// are accepted as valid, but those characters must never be
+// interpreted by an [FS] implementation as path element separators.
+export function ValidPath(name: string): boolean {
+	if (!utf8.ValidString(name)) {
+		return false
+	}
+
+	// special case
+	if (name == ".") {
+		// special case
+		return true
+	}
+
+	// Iterate over elements in name, checking each.
+
+	// reached clean ending
+	for (; ; ) {
+		let i = 0
+		for (; i < $.len(name) && $.indexString(name, i) != 47; ) {
+			i++
+		}
+		let elem = $.sliceString(name, undefined, i)
+		if (elem == "" || elem == "." || elem == "..") {
+			return false
+		}
+
+		// reached clean ending
+		if (i == $.len(name)) {
+			return true
+		}
+		name = $.sliceString(name, i + 1, undefined)
+	}
+}
+
+export type File = null | {
+	Close(): $.GoError
+	Read(_p0: Uint8Array): [number, $.GoError]
+	Stat(): [FileInfo, $.GoError]
+}
+
+$.registerInterfaceType(
+  'File',
+  null, // Zero value for interface is null
+  [{ name: "Close", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Read", args: [{ name: "", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Stat", args: [], returns: [{ type: "FileInfo" }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }]
+);
+
+export type DirEntry = null | {
+	// Info returns the FileInfo for the file or subdirectory described by the entry.
+	// The returned FileInfo may be from the time of the original directory read
+	// or from the time of the call to Info. If the file has been removed or renamed
+	// since the directory read, Info may return an error satisfying errors.Is(err, ErrNotExist).
+	// If the entry denotes a symbolic link, Info reports the information about the link itself,
+	// not the link's target.
+	Info(): [FileInfo, $.GoError]
+	// IsDir reports whether the entry describes a directory.
+	IsDir(): boolean
+	// Name returns the name of the file (or subdirectory) described by the entry.
+	// This name is only the final element of the path (the base name), not the entire path.
+	// For example, Name would return "hello.go" not "home/gopher/hello.go".
+	Name(): string
+	// Type returns the type bits for the entry.
+	// The type bits are a subset of the usual FileMode bits, those returned by the FileMode.Type method.
+	Type(): FileMode
+}
+
+$.registerInterfaceType(
+  'DirEntry',
+  null, // Zero value for interface is null
+  [{ name: "Info", args: [], returns: [{ type: "FileInfo" }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "IsDir", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "Name", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }] }, { name: "Type", args: [], returns: [{ type: "FileMode" }] }]
+);
+
+export type ReadDirFile = null | {
+	// ReadDir reads the contents of the directory and returns
+	// a slice of up to n DirEntry values in directory order.
+	// Subsequent calls on the same file will yield further DirEntry values.
+	//
+	// If n > 0, ReadDir returns at most n DirEntry structures.
+	// In this case, if ReadDir returns an empty slice, it will return
+	// a non-nil error explaining why.
+	// At the end of a directory, the error is io.EOF.
+	// (ReadDir must return io.EOF itself, not an error wrapping io.EOF.)
+	//
+	// If n <= 0, ReadDir returns all the DirEntry values from the directory
+	// in a single slice. In this case, if ReadDir succeeds (reads all the way
+	// to the end of the directory), it returns the slice and a nil error.
+	// If it encounters an error before the end of the directory,
+	// ReadDir returns the DirEntry list read until that point and a non-nil error.
+	ReadDir(n: number): [$.Slice<DirEntry>, $.GoError]
+} & File
+
+$.registerInterfaceType(
+  'ReadDirFile',
+  null, // Zero value for interface is null
+  [{ name: "ReadDir", args: [{ name: "n", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Slice, elemType: "DirEntry" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }]
+);
+
+// "invalid argument"
+export let ErrInvalid: $.GoError = errInvalid()
+
+// "permission denied"
+export let ErrPermission: $.GoError = errPermission()
+
+// "file already exists"
+export let ErrExist: $.GoError = errExist()
+
+// "file does not exist"
+export let ErrNotExist: $.GoError = errNotExist()
+
+// "file already closed"
+export let ErrClosed: $.GoError = errClosed()
+
+export function errInvalid(): $.GoError {
+	return oserror.ErrInvalid
+}
+
+export function errPermission(): $.GoError {
+	return oserror.ErrPermission
+}
+
+export function errExist(): $.GoError {
+	return oserror.ErrExist
+}
+
+export function errNotExist(): $.GoError {
+	return oserror.ErrNotExist
+}
+
+export function errClosed(): $.GoError {
+	return oserror.ErrClosed
+}
+
+export type FileInfo = null | {
+	// abbreviation for Mode().IsDir()
+	IsDir(): boolean
+	// modification time
+	ModTime(): time.Time
+	// file mode bits
+	Mode(): FileMode
+	// base name of the file
+	Name(): string
+	// length in bytes for regular files; system-dependent for others
+	Size(): number
+	// underlying data source (can return nil)
+	Sys(): null | any
+}
+
+$.registerInterfaceType(
+  'FileInfo',
+  null, // Zero value for interface is null
+  [{ name: "IsDir", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "ModTime", args: [], returns: [{ type: "Time" }] }, { name: "Mode", args: [], returns: [{ type: "FileMode" }] }, { name: "Name", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }] }, { name: "Size", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Sys", args: [], returns: [{ type: { kind: $.TypeKind.Interface, methods: [] } }] }]
+);
+
+export type FileMode = number;
+
+// The single letters are the abbreviations
+// used by the String method's formatting.
+// d: is a directory
+export let ModeDir: FileMode = 2147483648
+
+// a: append-only
+export let ModeAppend: FileMode = 0
+
+// l: exclusive use
+export let ModeExclusive: FileMode = 0
+
+// T: temporary file; Plan 9 only
+export let ModeTemporary: FileMode = 0
+
+// L: symbolic link
+export let ModeSymlink: FileMode = 0
+
+// D: device file
+export let ModeDevice: FileMode = 0
+
+// p: named pipe (FIFO)
+export let ModeNamedPipe: FileMode = 0
+
+// S: Unix domain socket
+export let ModeSocket: FileMode = 0
+
+// u: setuid
+export let ModeSetuid: FileMode = 0
+
+// g: setgid
+export let ModeSetgid: FileMode = 0
+
+// c: Unix character device, when ModeDevice is set
+export let ModeCharDevice: FileMode = 0
+
+// t: sticky
+export let ModeSticky: FileMode = 0
+
+// ?: non-regular file; nothing else is known about this file
+export let ModeIrregular: FileMode = 0
+
+// Mask for the type bits. For regular files, none will be set.
+export let ModeType: FileMode = ((((((2147483648 | 134217728) | 33554432) | 16777216) | 67108864) | 2097152) | 524288)
+
+// Unix permission bits
+export let ModePerm: FileMode = 0o777
+
+// FileMode methods
+export function fileModeString(mode: FileMode): string {
+	const buf: string[] = []
+	
+	// File type
+	if (mode & ModeDir) buf.push("d")
+	else if (mode & ModeSymlink) buf.push("L")
+	else if (mode & ModeDevice) buf.push("D")
+	else if (mode & ModeNamedPipe) buf.push("p")
+	else if (mode & ModeSocket) buf.push("S")
+	else if (mode & ModeCharDevice) buf.push("c")
+	else if (mode & ModeIrregular) buf.push("?")
+	else buf.push("-")
+	
+	// Permission bits
+	const perm = mode & ModePerm
+	buf.push((perm & 0o400) ? "r" : "-")
+	buf.push((perm & 0o200) ? "w" : "-")
+	buf.push((perm & 0o100) ? "x" : "-")
+	buf.push((perm & 0o040) ? "r" : "-")
+	buf.push((perm & 0o020) ? "w" : "-")
+	buf.push((perm & 0o010) ? "x" : "-")
+	buf.push((perm & 0o004) ? "r" : "-")
+	buf.push((perm & 0o002) ? "w" : "-")
+	buf.push((perm & 0o001) ? "x" : "-")
+	
+	return buf.join("")
+}
+
+export function fileModeType(mode: FileMode): FileMode {
+	return mode & ModeType
+}
+
+export class PathError {
+	public get Op(): string {
+		return this._fields.Op.value
+	}
+	public set Op(value: string) {
+		this._fields.Op.value = value
+	}
+
+	public get Path(): string {
+		return this._fields.Path.value
+	}
+	public set Path(value: string) {
+		this._fields.Path.value = value
+	}
+
+	public get Err(): $.GoError {
+		return this._fields.Err.value
+	}
+	public set Err(value: $.GoError) {
+		this._fields.Err.value = value
+	}
+
+	public _fields: {
+		Op: $.VarRef<string>;
+		Path: $.VarRef<string>;
+		Err: $.VarRef<$.GoError>;
+	}
+
+	constructor(init?: Partial<{Err?: $.GoError, Op?: string, Path?: string}>) {
+		this._fields = {
+			Op: $.varRef(init?.Op ?? ""),
+			Path: $.varRef(init?.Path ?? ""),
+			Err: $.varRef(init?.Err ?? null)
+		}
+	}
+
+	public clone(): PathError {
+		const cloned = new PathError()
+		cloned._fields = {
+			Op: $.varRef(this._fields.Op.value),
+			Path: $.varRef(this._fields.Path.value),
+			Err: $.varRef(this._fields.Err.value)
+		}
+		return cloned
+	}
+
+	public Error(): string {
+		const e = this
+		return e!.Op + " " + e!.Path + ": " + e!.Err!.Error()
+	}
+
+	public Unwrap(): $.GoError {
+		const e = this
+		return e!.Err
+	}
+
+	// Timeout reports whether this error represents a timeout.
+	public Timeout(): boolean {
+		const e = this
+		let { value: t, ok: ok } = $.typeAssert<null | {
+			Timeout(): boolean
+		}>(e!.Err, {kind: $.TypeKind.Interface, methods: [{ name: 'Timeout', args: [], returns: [{ type: {kind: $.TypeKind.Basic, name: 'boolean'} }] }]})
+		return ok && t!.Timeout()
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+	  'PathError',
+	  new PathError(),
+	  [{ name: "Error", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }] }, { name: "Unwrap", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Timeout", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }],
+	  PathError,
+	  {"Op": { kind: $.TypeKind.Basic, name: "string" }, "Path": { kind: $.TypeKind.Basic, name: "string" }, "Err": { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] }}
+	);
+}
+

package/gs/io/fs/glob.ts

@@ -0,0 +1,167 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { Stat } from "./stat.js";
+import { ReadDir } from "./readdir.js";
+import { FS } from "./fs.js";
+
+import * as path from "@goscript/path/index.js"
+
+export type GlobFS = null | {
+	// Glob returns the names of all files matching pattern,
+	// providing an implementation of the top-level
+	// Glob function.
+	Glob(pattern: string): [$.Slice<string>, $.GoError]
+} & FS
+
+$.registerInterfaceType(
+  'GlobFS',
+  null, // Zero value for interface is null
+  [{ name: "Glob", args: [{ name: "pattern", type: { kind: $.TypeKind.Basic, name: "string" } }], returns: [{ type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "string" } } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }]
+);
+
+// Glob returns the names of all files matching pattern or nil
+// if there is no matching file. The syntax of patterns is the same
+// as in [path.Match]. The pattern may describe hierarchical names such as
+// usr/*/bin/ed.
+//
+// Glob ignores file system errors such as I/O errors reading directories.
+// The only possible returned error is [path.ErrBadPattern], reporting that
+// the pattern is malformed.
+//
+// If fs implements [GlobFS], Glob calls fs.Glob.
+// Otherwise, Glob uses [ReadDir] to traverse the directory tree
+// and look for matches for the pattern.
+export function Glob(fsys: FS, pattern: string): [$.Slice<string>, $.GoError] {
+	let matches: $.Slice<string> = null
+	let err: $.GoError = null
+	{
+		return globWithLimit(fsys, pattern, 0)
+	}
+}
+
+export function globWithLimit(fsys: FS, pattern: string, depth: number): [$.Slice<string>, $.GoError] {
+	let matches: $.Slice<string> = null
+	let err: $.GoError = null
+	{
+		// This limit is added to prevent stack exhaustion issues. See
+		// CVE-2022-30630.
+		let pathSeparatorsLimit: number = 10000
+		if (depth > 10000) {
+			return [null, path.ErrBadPattern]
+		}
+		{
+			let { value: fsysTyped, ok: ok } = $.typeAssert<GlobFS>(fsys, 'GlobFS')
+			if (ok) {
+				return fsysTyped!.Glob(pattern)
+			}
+		}
+
+		// Check pattern is well-formed.
+		{
+			let [, err] = path.Match(pattern, "")
+			if (err != null) {
+				return [null, err]
+			}
+		}
+		if (!hasMeta(pattern)) {
+			{
+				[, err] = Stat(fsys, pattern)
+				if (err != null) {
+					return [null, null]
+				}
+			}
+			return [$.arrayToSlice<string>([pattern]), null]
+		}
+
+		let [dir, file] = path.Split(pattern)
+		dir = cleanGlobPath(dir)
+
+		if (!hasMeta(dir)) {
+			return glob(fsys, dir, file, null)
+		}
+
+		// Prevent infinite recursion. See issue 15879.
+		if (dir == pattern) {
+			return [null, path.ErrBadPattern]
+		}
+
+		let m: $.Slice<string>
+		[m, err] = globWithLimit(fsys, dir, depth + 1)
+		if (err != null) {
+			return [null, err]
+		}
+		for (let _i = 0; _i < $.len(m); _i++) {
+			const d = m![_i]
+			{
+				[matches, err] = glob(fsys, d, file, matches)
+				if (err != null) {
+					return [matches, err]
+				}
+			}
+		}
+		return [matches, err]
+	}
+}
+
+// cleanGlobPath prepares path for glob matching.
+export function cleanGlobPath(path: string): string {
+
+	// chop off trailing separator
+	switch (path) {
+		case "":
+			return "."
+			break
+		default:
+			return $.sliceString(path, 0, $.len(path) - 1)
+			break
+	}
+}
+
+// glob searches for files matching pattern in the directory dir
+// and appends them to matches, returning the updated slice.
+// If the directory cannot be opened, glob returns the existing matches.
+// New matches are added in lexicographical order.
+export function glob(fs: FS, dir: string, pattern: string, matches: $.Slice<string>): [$.Slice<string>, $.GoError] {
+	let m: $.Slice<string> = null
+	let e: $.GoError = null
+	{
+		m = matches
+		let [infos, err] = ReadDir(fs, dir)
+
+		// ignore I/O error
+		if (err != null) {
+			return [m, e]
+		}
+
+		for (let _i = 0; _i < $.len(infos); _i++) {
+			const info = infos![_i]
+			{
+				let n = info!.Name()
+				let [matched, err] = path.Match(pattern, n)
+				if (err != null) {
+					return [m, err]
+				}
+				if (matched) {
+					m = $.append(m, path.Join(dir, n))
+				}
+			}
+		}
+		return [m, e]
+	}
+}
+
+// hasMeta reports whether path contains any of the magic characters
+// recognized by path.Match.
+export function hasMeta(path: string): boolean {
+	for (let i = 0; i < $.len(path); i++) {
+		switch ($.indexString(path, i)) {
+			case 42:
+			case 63:
+			case 91:
+			case 92:
+				return true
+				break
+		}
+	}
+	return false
+}
+

package/gs/io/fs/godoc.txt

@@ -0,0 +1,35 @@
+package fs // import "io/fs"
+
+Package fs defines basic interfaces to a file system. A file system can be
+provided by the host operating system but also by other packages.
+
+See the testing/fstest package for support with testing implementations of file
+systems.
+
+var ErrInvalid = errInvalid() ...
+var SkipAll = errors.New("skip everything and stop the walk")
+var SkipDir = errors.New("skip this directory")
+func FormatDirEntry(dir DirEntry) string
+func FormatFileInfo(info FileInfo) string
+func Glob(fsys FS, pattern string) (matches []string, err error)
+func ReadFile(fsys FS, name string) ([]byte, error)
+func ValidPath(name string) bool
+func WalkDir(fsys FS, root string, fn WalkDirFunc) error
+type DirEntry interface{ ... }
+    func FileInfoToDirEntry(info FileInfo) DirEntry
+    func ReadDir(fsys FS, name string) ([]DirEntry, error)
+type FS interface{ ... }
+    func Sub(fsys FS, dir string) (FS, error)
+type File interface{ ... }
+type FileInfo interface{ ... }
+    func Stat(fsys FS, name string) (FileInfo, error)
+type FileMode uint32
+    const ModeDir FileMode = 1 << (32 - 1 - iota) ...
+type GlobFS interface{ ... }
+type PathError struct{ ... }
+type ReadDirFS interface{ ... }
+type ReadDirFile interface{ ... }
+type ReadFileFS interface{ ... }
+type StatFS interface{ ... }
+type SubFS interface{ ... }
+type WalkDirFunc func(path string, d DirEntry, err error) error

package/gs/io/fs/index.ts

@@ -0,0 +1,8 @@
+export * from "./format.js"
+export * from "./fs.js"
+export * from "./glob.js"
+export * from "./readdir.js"
+export * from "./readfile.js"
+export * from "./stat.js"
+export * from "./sub.js"
+export * from "./walk.js"

package/gs/io/fs/readdir.ts

@@ -0,0 +1,126 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { FormatDirEntry } from "./format.js";
+import { FS, DirEntry, ReadDirFile, PathError, FileInfo, FileMode, fileModeType } from "./fs.js";
+
+import * as errors from "@goscript/errors/index.js"
+
+import * as slices from "@goscript/slices/index.js"
+
+export type ReadDirFS = null | {
+	// ReadDir reads the named directory
+	// and returns a list of directory entries sorted by filename.
+	ReadDir(name: string): [$.Slice<DirEntry>, $.GoError]
+} & FS
+
+$.registerInterfaceType(
+  'ReadDirFS',
+  null, // Zero value for interface is null
+  [{ name: "ReadDir", args: [{ name: "name", type: { kind: $.TypeKind.Basic, name: "string" } }], returns: [{ type: { kind: $.TypeKind.Slice, elemType: "DirEntry" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }]
+);
+
+// ReadDir reads the named directory
+// and returns a list of directory entries sorted by filename.
+//
+// If fs implements [ReadDirFS], ReadDir calls fs.ReadDir.
+// Otherwise ReadDir calls fs.Open and uses ReadDir and Close
+// on the returned file.
+export function ReadDir(fsys: FS, name: string): [$.Slice<DirEntry>, $.GoError] {
+	using __defer = new $.DisposableStack();
+	{
+		let { value: fsysTyped, ok: ok } = $.typeAssert<ReadDirFS>(fsys, 'ReadDirFS')
+		if (ok) {
+			return fsysTyped!.ReadDir(name)
+		}
+	}
+
+	let [file, err] = fsys!.Open(name)
+	if (err != null) {
+		return [null, err]
+	}
+	__defer.defer(() => {
+		file!.Close()
+	});
+
+	let { value: dir, ok: ok } = $.typeAssert<ReadDirFile>(file, 'ReadDirFile')
+	if (!ok) {
+		return [null, new PathError({Err: errors.New("not implemented"), Op: "readdir", Path: name})]
+	}
+
+	let list: $.Slice<DirEntry>
+	[list, err] = dir!.ReadDir(-1)
+	list!.sort((a: DirEntry, b: DirEntry): number => {
+		return a!.Name().localeCompare(b!.Name())
+	})
+	return [list, err]
+}
+
+class dirInfo {
+	public get fileInfo(): FileInfo {
+		return this._fields.fileInfo.value
+	}
+	public set fileInfo(value: FileInfo) {
+		this._fields.fileInfo.value = value
+	}
+
+	public _fields: {
+		fileInfo: $.VarRef<FileInfo>;
+	}
+
+	constructor(init?: Partial<{fileInfo?: FileInfo}>) {
+		this._fields = {
+			fileInfo: $.varRef(init?.fileInfo ?? null)
+		}
+	}
+
+	public clone(): dirInfo {
+		const cloned = new dirInfo()
+		cloned._fields = {
+			fileInfo: $.varRef(this._fields.fileInfo.value)
+		}
+		return cloned
+	}
+
+	public IsDir(): boolean {
+		const di = this
+		return di.fileInfo!.IsDir()
+	}
+
+	public Type(): FileMode {
+		const di = this
+		return fileModeType(di.fileInfo!.Mode())
+	}
+
+	public Info(): [FileInfo, $.GoError] {
+		const di = this
+		return [di.fileInfo, null]
+	}
+
+	public Name(): string {
+		const di = this
+		return di.fileInfo!.Name()
+	}
+
+	public String(): string {
+		const di = this
+		return FormatDirEntry(di)
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+	  'dirInfo',
+	  new dirInfo(),
+	  [{ name: "IsDir", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "Type", args: [], returns: [{ type: "FileMode" }] }, { name: "Info", args: [], returns: [{ type: "FileInfo" }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Name", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }] }, { name: "String", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }] }],
+	  dirInfo,
+	  {"fileInfo": "FileInfo"}
+	);
+}
+
+// FileInfoToDirEntry returns a [DirEntry] that returns information from info.
+// If info is nil, FileInfoToDirEntry returns nil.
+export function FileInfoToDirEntry(info: FileInfo): DirEntry {
+	if (info == null) {
+		return null
+	}
+	return new dirInfo({fileInfo: info})
+}
+