goscript 0.0.26 → 0.0.29

package/gs/io/fs/readfile.ts

@@ -0,0 +1,77 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { FS } from "./fs.js";
+
+import * as io from "@goscript/io/index.js"
+
+export type ReadFileFS = null | {
+	// ReadFile reads the named file and returns its contents.
+	// A successful call returns a nil error, not io.EOF.
+	// (Because ReadFile reads the whole file, the expected EOF
+	// from the final Read is not treated as an error to be reported.)
+	//
+	// The caller is permitted to modify the returned byte slice.
+	// This method should return a copy of the underlying data.
+	ReadFile(name: string): [Uint8Array, $.GoError]
+} & FS
+
+$.registerInterfaceType(
+  'ReadFileFS',
+  null, // Zero value for interface is null
+  [{ name: "ReadFile", args: [{ name: "name", type: { kind: $.TypeKind.Basic, name: "string" } }], returns: [{ type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }]
+);
+
+// ReadFile reads the named file from the file system fs and returns its contents.
+// A successful call returns a nil error, not [io.EOF].
+// (Because ReadFile reads the whole file, the expected EOF
+// from the final Read is not treated as an error to be reported.)
+//
+// If fs implements [ReadFileFS], ReadFile calls fs.ReadFile.
+// Otherwise ReadFile calls fs.Open and uses Read and Close
+// on the returned [File].
+export function ReadFile(fsys: FS, name: string): [Uint8Array, $.GoError] {
+	using __defer = new $.DisposableStack();
+	{
+		let { value: fsysTyped, ok: ok } = $.typeAssert<ReadFileFS>(fsys, 'ReadFileFS')
+		if (ok) {
+			return fsysTyped!.ReadFile(name)
+		}
+	}
+
+	let [file, err] = fsys!.Open(name)
+	if (err != null) {
+		return [new Uint8Array(0), err]
+	}
+	__defer.defer(() => {
+		file!.Close()
+	});
+
+	let size: number = 0
+	{
+		let [info, err] = file!.Stat()
+		if (err == null) {
+			let size64 = info!.Size()
+			if (((size64 as number) as number) == size64) {
+				size = (size64 as number)
+			}
+		}
+	}
+
+	let data = new Uint8Array(0)
+	for (; ; ) {
+		if ($.len(data) >= $.cap(data)) {
+			// Grow the array by creating a new larger one
+			let newData = new Uint8Array($.len(data) * 2 + 1)
+			newData.set(data)
+			data = newData
+		}
+		let [n, err] = file!.Read(data.subarray($.len(data), $.cap(data)))
+		data = data.subarray(0, $.len(data) + n)
+		if (err != null) {
+			if (err == io.EOF) {
+				err = null
+			}
+			return [data, err]
+		}
+	}
+}
+

package/gs/io/fs/stat.ts

@@ -0,0 +1,38 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { FS, FileInfo } from "./fs.js";
+
+export type StatFS = null | {
+	// Stat returns a FileInfo describing the file.
+	// If there is an error, it should be of type *PathError.
+	Stat(name: string): [FileInfo, $.GoError]
+} & FS
+
+$.registerInterfaceType(
+  'StatFS',
+  null, // Zero value for interface is null
+  [{ name: "Stat", args: [{ name: "name", type: { kind: $.TypeKind.Basic, name: "string" } }], returns: [{ type: "FileInfo" }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }]
+);
+
+// Stat returns a [FileInfo] describing the named file from the file system.
+//
+// If fs implements [StatFS], Stat calls fs.Stat.
+// Otherwise, Stat opens the [File] to stat it.
+export function Stat(fsys: FS, name: string): [FileInfo, $.GoError] {
+	using __defer = new $.DisposableStack();
+	{
+		let { value: fsysTyped, ok: ok } = $.typeAssert<StatFS>(fsys, 'StatFS')
+		if (ok) {
+			return fsysTyped!.Stat(name)
+		}
+	}
+
+	let [file, err] = fsys!.Open(name)
+	if (err != null) {
+		return [null, err]
+	}
+	__defer.defer(() => {
+		file!.Close()
+	});
+	return file!.Stat()
+}
+

package/gs/io/fs/sub.ts

@@ -0,0 +1,208 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { ValidPath, FS, PathError, ErrInvalid, File, DirEntry } from "./fs.js";
+import { ReadDir } from "./readdir.js";
+import { ReadFile } from "./readfile.js";
+import { Glob } from "./glob.js";
+
+import * as errors from "@goscript/errors/index.js"
+
+import * as path from "@goscript/path/index.js"
+
+export type SubFS = null | {
+	// Sub returns an FS corresponding to the subtree rooted at dir.
+	Sub(dir: string): [FS, $.GoError]
+} & FS
+
+$.registerInterfaceType(
+  'SubFS',
+  null, // Zero value for interface is null
+  [{ name: "Sub", args: [{ name: "dir", type: { kind: $.TypeKind.Basic, name: "string" } }], returns: [{ type: "FS" }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }]
+);
+
+// Sub returns an [FS] corresponding to the subtree rooted at fsys's dir.
+//
+// If dir is ".", Sub returns fsys unchanged.
+// Otherwise, if fs implements [SubFS], Sub returns fsys.Sub(dir).
+// Otherwise, Sub returns a new [FS] implementation sub that,
+// in effect, implements sub.Open(name) as fsys.Open(path.Join(dir, name)).
+// The implementation also translates calls to ReadDir, ReadFile, and Glob appropriately.
+//
+// Note that Sub(os.DirFS("/"), "prefix") is equivalent to os.DirFS("/prefix")
+// and that neither of them guarantees to avoid operating system
+// accesses outside "/prefix", because the implementation of [os.DirFS]
+// does not check for symbolic links inside "/prefix" that point to
+// other directories. That is, [os.DirFS] is not a general substitute for a
+// chroot-style security mechanism, and Sub does not change that fact.
+export function Sub(fsys: FS, dir: string): [FS, $.GoError] {
+	if (!ValidPath(dir)) {
+		return [null, new PathError({Err: ErrInvalid, Op: "sub", Path: dir})]
+	}
+	if (dir == ".") {
+		return [fsys, null]
+	}
+	{
+		let { value: fsysTyped, ok: ok } = $.typeAssert<SubFS>(fsys, 'SubFS')
+		if (ok) {
+			return fsysTyped!.Sub(dir)
+		}
+	}
+	return [new subFS({}), null]
+}
+
+class subFS {
+	public get fsys(): FS {
+		return this._fields.fsys.value
+	}
+	public set fsys(value: FS) {
+		this._fields.fsys.value = value
+	}
+
+	public get dir(): string {
+		return this._fields.dir.value
+	}
+	public set dir(value: string) {
+		this._fields.dir.value = value
+	}
+
+	public _fields: {
+		fsys: $.VarRef<FS>;
+		dir: $.VarRef<string>;
+	}
+
+	constructor(init?: Partial<{dir?: string, fsys?: FS}>) {
+		this._fields = {
+			fsys: $.varRef(init?.fsys ?? null),
+			dir: $.varRef(init?.dir ?? "")
+		}
+	}
+
+	public clone(): subFS {
+		const cloned = new subFS()
+		cloned._fields = {
+			fsys: $.varRef(this._fields.fsys.value),
+			dir: $.varRef(this._fields.dir.value)
+		}
+		return cloned
+	}
+
+	// fullName maps name to the fully-qualified name dir/name.
+	public fullName(op: string, name: string): [string, $.GoError] {
+		const f = this
+		if (!ValidPath(name)) {
+			return ["", new PathError({Err: ErrInvalid, Op: op, Path: name})]
+		}
+		return [path.Join(f!.dir, name), null]
+	}
+
+	// shorten maps name, which should start with f.dir, back to the suffix after f.dir.
+	public shorten(name: string): [string, boolean] {
+		const f = this
+		if (name == f!.dir) {
+			return [".", true]
+		}
+		if ($.len(name) >= $.len(f!.dir) + 2 && $.indexString(name, $.len(f!.dir)) == 47 && $.sliceString(name, undefined, $.len(f!.dir)) == f!.dir) {
+			return [$.sliceString(name, $.len(f!.dir) + 1, undefined), true]
+		}
+		return ["", false]
+	}
+
+	// fixErr shortens any reported names in PathErrors by stripping f.dir.
+	public fixErr(err: $.GoError): $.GoError {
+		const f = this
+		{
+			let { value: e, ok: ok } = $.typeAssert<PathError | null>(err, {kind: $.TypeKind.Pointer, elemType: 'PathError'})
+			if (ok) {
+				{
+					let [short, ok] = f!.shorten(e!.Path)
+					if (ok) {
+						e!.Path = short
+					}
+				}
+			}
+		}
+		return err
+	}
+
+	public Open(name: string): [File, $.GoError] {
+		const f = this
+		let [full, err] = f!.fullName("open", name)
+		if (err != null) {
+			return [null, err]
+		}
+		let file: File
+		[file, err] = f!.fsys!.Open(full)
+		return [file, f!.fixErr(err)]
+	}
+
+	public ReadDir(name: string): [$.Slice<DirEntry>, $.GoError] {
+		const f = this
+		let [full, err] = f!.fullName("read", name)
+		if (err != null) {
+			return [null, err]
+		}
+		let dir: $.Slice<DirEntry>
+		[dir, err] = ReadDir(f!.fsys, full)
+		return [dir, f!.fixErr(err)]
+	}
+
+	public ReadFile(name: string): [Uint8Array, $.GoError] {
+		const f = this
+		let [full, err] = f!.fullName("read", name)
+		if (err != null) {
+			return [new Uint8Array(0), err]
+		}
+		let data: Uint8Array
+		[data, err] = ReadFile(f!.fsys, full)
+		return [data, f!.fixErr(err)]
+	}
+
+	public Glob(pattern: string): [$.Slice<string>, $.GoError] {
+		const f = this
+		{
+			let [, err] = path.Match(pattern, "")
+			if (err != null) {
+				return [null, err]
+			}
+		}
+		if (pattern == ".") {
+			return [$.arrayToSlice<string>(["."]), null]
+		}
+		let full = f!.dir + "/" + pattern
+		let [list, err] = Glob(f!.fsys, full)
+		for (let i = 0; i < $.len(list); i++) {
+			const name = list![i]
+			{
+				let [shortName, ok] = f!.shorten(name)
+
+				// can't use fmt in this package
+				if (!ok) {
+					return [null, errors.New("invalid result from inner fsys Glob: " + shortName + " not in " + f!.dir)]
+				}
+				list![i] = shortName
+			}
+		}
+		return [list, f!.fixErr(err)]
+	}
+
+	public Sub(dir: string): [FS, $.GoError] {
+		const f = this
+		if (dir == ".") {
+			return [f, null]
+		}
+		let [full, err] = f!.fullName("sub", dir)
+		if (err != null) {
+			return [null, err]
+		}
+		return [new subFS({}), null]
+	}
+
+	// Register this type with the runtime type system
+	static __typeInfo = $.registerStructType(
+	  'subFS',
+	  new subFS(),
+	  [{ name: "fullName", args: [{ name: "op", type: { kind: $.TypeKind.Basic, name: "string" } }, { name: "name", type: { kind: $.TypeKind.Basic, name: "string" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "shorten", args: [{ name: "name", type: { kind: $.TypeKind.Basic, name: "string" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }, { type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "fixErr", args: [{ name: "err", type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { 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' } }] }] } }] }, { 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' } }] }] } }] }, { name: "ReadFile", args: [{ name: "name", type: { kind: $.TypeKind.Basic, name: "string" } }], returns: [{ type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { 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' } }] }] } }] }, { name: "Sub", args: [{ name: "dir", type: { kind: $.TypeKind.Basic, name: "string" } }], returns: [{ type: "FS" }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }],
+	  subFS,
+	  {"fsys": "FS", "dir": { kind: $.TypeKind.Basic, name: "string" }}
+	);
+}
+

package/gs/io/fs/walk.ts

@@ -0,0 +1,89 @@
+import * as $ from "@goscript/builtin/builtin.js";
+import { FileInfoToDirEntry, ReadDir } from "./readdir.js";
+import { Stat } from "./stat.js";
+import { FS, DirEntry } from "./fs.js";
+
+import * as errors from "@goscript/errors/index.js"
+
+import * as path from "@goscript/path/index.js"
+
+export let SkipDir: $.GoError = errors.New("skip this directory")
+
+export let SkipAll: $.GoError = errors.New("skip everything and stop the walk")
+
+export type WalkDirFunc = ((path: string, d: DirEntry, err: $.GoError) => $.GoError) | null;
+
+// walkDir recursively descends path, calling walkDirFn.
+export function walkDir(fsys: FS, name: string, d: DirEntry, walkDirFn: WalkDirFunc): $.GoError {
+
+	// Successfully skipped directory.
+	{
+		let err = walkDirFn!(name, d, null)
+		if (err != null || !d!.IsDir()) {
+
+			// Successfully skipped directory.
+			if (err == SkipDir && d!.IsDir()) {
+				// Successfully skipped directory.
+				err = null
+			}
+			return err
+		}
+	}
+
+	let [dirs, err] = ReadDir(fsys, name)
+
+	// Second call, to report ReadDir error.
+	if (err != null) {
+		// Second call, to report ReadDir error.
+		err = walkDirFn!(name, d, err)
+		if (err != null) {
+			if (err == SkipDir && d!.IsDir()) {
+				err = null
+			}
+			return err
+		}
+	}
+
+	for (let _i = 0; _i < $.len(dirs); _i++) {
+		const d1 = dirs![_i]
+		{
+			let name1 = path.Join(name, d1!.Name())
+			{
+				let err = walkDir(fsys, name1, d1, walkDirFn)
+				if (err != null) {
+					if (err == SkipDir) {
+						break
+					}
+					return err
+				}
+			}
+		}
+	}
+	return null
+}
+
+// WalkDir walks the file tree rooted at root, calling fn for each file or
+// directory in the tree, including root.
+//
+// All errors that arise visiting files and directories are filtered by fn:
+// see the [fs.WalkDirFunc] documentation for details.
+//
+// The files are walked in lexical order, which makes the output deterministic
+// but requires WalkDir to read an entire directory into memory before proceeding
+// to walk that directory.
+//
+// WalkDir does not follow symbolic links found in directories,
+// but if root itself is a symbolic link, its target will be walked.
+export function WalkDir(fsys: FS, root: string, fn: WalkDirFunc): $.GoError {
+	let [info, err] = Stat(fsys, root)
+	if (err != null) {
+		err = fn!(root, null, err)
+	} else {
+		err = walkDir(fsys, root, FileInfoToDirEntry(info), fn)
+	}
+	if (err == SkipDir || err == SkipAll) {
+		return null
+	}
+	return err
+}
+

package/gs/io/godoc.txt

@@ -0,0 +1,61 @@
+package io // import "io"
+
+Package io provides basic interfaces to I/O primitives. Its primary job is to
+wrap existing implementations of such primitives, such as those in package os,
+into shared public interfaces that abstract the functionality, plus some other
+related primitives.
+
+Because these interfaces and primitives wrap lower-level operations with various
+implementations, unless otherwise informed clients should not assume they are
+safe for parallel execution.
+
+const SeekStart = 0 ...
+var EOF = errors.New("EOF")
+var ErrClosedPipe = errors.New("io: read/write on closed pipe")
+var ErrNoProgress = errors.New("multiple Read calls return no data or error")
+var ErrShortBuffer = errors.New("short buffer")
+var ErrShortWrite = errors.New("short write")
+var ErrUnexpectedEOF = errors.New("unexpected EOF")
+func Copy(dst Writer, src Reader) (written int64, err error)
+func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error)
+func CopyN(dst Writer, src Reader, n int64) (written int64, err error)
+func Pipe() (*PipeReader, *PipeWriter)
+func ReadAll(r Reader) ([]byte, error)
+func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error)
+func ReadFull(r Reader, buf []byte) (n int, err error)
+func WriteString(w Writer, s string) (n int, err error)
+type ByteReader interface{ ... }
+type ByteScanner interface{ ... }
+type ByteWriter interface{ ... }
+type Closer interface{ ... }
+type LimitedReader struct{ ... }
+type OffsetWriter struct{ ... }
+    func NewOffsetWriter(w WriterAt, off int64) *OffsetWriter
+type PipeReader struct{ ... }
+type PipeWriter struct{ ... }
+type ReadCloser interface{ ... }
+    func NopCloser(r Reader) ReadCloser
+type ReadSeekCloser interface{ ... }
+type ReadSeeker interface{ ... }
+type ReadWriteCloser interface{ ... }
+type ReadWriteSeeker interface{ ... }
+type ReadWriter interface{ ... }
+type Reader interface{ ... }
+    func LimitReader(r Reader, n int64) Reader
+    func MultiReader(readers ...Reader) Reader
+    func TeeReader(r Reader, w Writer) Reader
+type ReaderAt interface{ ... }
+type ReaderFrom interface{ ... }
+type RuneReader interface{ ... }
+type RuneScanner interface{ ... }
+type SectionReader struct{ ... }
+    func NewSectionReader(r ReaderAt, off int64, n int64) *SectionReader
+type Seeker interface{ ... }
+type StringWriter interface{ ... }
+type WriteCloser interface{ ... }
+type WriteSeeker interface{ ... }
+type Writer interface{ ... }
+    var Discard Writer = discard{}
+    func MultiWriter(writers ...Writer) Writer
+type WriterAt interface{ ... }
+type WriterTo interface{ ... }

package/gs/io/index.ts

@@ -0,0 +1 @@
+export * from './io.js'

package/gs/io/io.go

@@ -0,0 +1,75 @@
+package io
+
+import "github.com/aperturerobotics/goscript/compiler"
+
+// Metadata for io package functions
+// This defines which functions/methods are async for the compiler analysis
+
+// Most io operations are synchronous in our implementation
+// since we're dealing with in-memory operations and simple transformations
+
+// Copy functions - these could potentially be async if dealing with large data
+// but for simplicity, we'll keep them sync for now
+var (
+	CopyInfo       = compiler.FunctionInfo{IsAsync: false}
+	CopyBufferInfo = compiler.FunctionInfo{IsAsync: false}
+	CopyNInfo      = compiler.FunctionInfo{IsAsync: false}
+)
+
+// Read functions - sync since they're immediate operations
+var (
+	ReadAllInfo     = compiler.FunctionInfo{IsAsync: false}
+	ReadAtLeastInfo = compiler.FunctionInfo{IsAsync: false}
+	ReadFullInfo    = compiler.FunctionInfo{IsAsync: false}
+)
+
+// Write functions - sync
+var WriteStringInfo = compiler.FunctionInfo{IsAsync: false}
+
+// Utility functions - sync
+var (
+	LimitReaderInfo      = compiler.FunctionInfo{IsAsync: false}
+	MultiReaderInfo      = compiler.FunctionInfo{IsAsync: false}
+	MultiWriterInfo      = compiler.FunctionInfo{IsAsync: false}
+	TeeReaderInfo        = compiler.FunctionInfo{IsAsync: false}
+	NopCloserInfo        = compiler.FunctionInfo{IsAsync: false}
+	NewSectionReaderInfo = compiler.FunctionInfo{IsAsync: false}
+	NewOffsetWriterInfo  = compiler.FunctionInfo{IsAsync: false}
+)
+
+// Interface methods - sync for basic operations
+// Reader methods
+var ReaderReadInfo = compiler.FunctionInfo{IsAsync: false}
+
+// Writer methods
+var WriterWriteInfo = compiler.FunctionInfo{IsAsync: false}
+
+// Closer methods
+var CloserCloseInfo = compiler.FunctionInfo{IsAsync: false}
+
+// Seeker methods
+var SeekerSeekInfo = compiler.FunctionInfo{IsAsync: false}
+
+// ReaderAt methods
+var ReaderAtReadAtInfo = compiler.FunctionInfo{IsAsync: false}
+
+// WriterAt methods
+var WriterAtWriteAtInfo = compiler.FunctionInfo{IsAsync: false}
+
+// LimitedReader methods
+var LimitedReaderReadInfo = compiler.FunctionInfo{IsAsync: false}
+
+// SectionReader methods
+var (
+	SectionReaderReadInfo   = compiler.FunctionInfo{IsAsync: false}
+	SectionReaderSeekInfo   = compiler.FunctionInfo{IsAsync: false}
+	SectionReaderReadAtInfo = compiler.FunctionInfo{IsAsync: false}
+	SectionReaderSizeInfo   = compiler.FunctionInfo{IsAsync: false}
+)
+
+// OffsetWriter methods
+var (
+	OffsetWriterWriteInfo   = compiler.FunctionInfo{IsAsync: false}
+	OffsetWriterWriteAtInfo = compiler.FunctionInfo{IsAsync: false}
+	OffsetWriterSeekInfo    = compiler.FunctionInfo{IsAsync: false}
+)