goscript 0.0.25 → 0.0.28

package/gs/errors/errors.ts

@@ -0,0 +1,223 @@
+import * as $ from '@goscript/builtin/builtin.js'
+
+// GoScriptError implements the Go error interface
+class GoScriptError {
+  constructor(private message: string) {}
+
+  Error(): string {
+    return this.message
+  }
+
+  toString(): string {
+    return this.message
+  }
+}
+
+// New returns an error that formats as the given text.
+// Each call to New returns a distinct error value even if the text is identical.
+export function New(text: string): $.GoError {
+  return new GoScriptError(text)
+}
+
+// ErrUnsupported indicates that a requested operation cannot be performed,
+// because it is unsupported. For example, a call to os.Link when using a
+// file system that does not support hard links.
+//
+// Functions and methods should not return this error but should instead
+// return an error including appropriate context that satisfies
+//
+//	errors.Is(err, errors.ErrUnsupported)
+//
+// either by directly wrapping ErrUnsupported or by implementing an Is method.
+export const ErrUnsupported = New('unsupported operation')
+
+// Unwrap returns the result of calling the Unwrap method on err, if err's
+// type contains an Unwrap method returning error.
+// Otherwise, Unwrap returns nil.
+export function Unwrap(err: $.GoError): $.GoError {
+  if (err === null) {
+    return null
+  }
+
+  // Check if the error has an Unwrap method
+  if (typeof (err as any).Unwrap === 'function') {
+    const result = (err as any).Unwrap()
+    if (result && typeof result.Error === 'function') {
+      return result
+    }
+    // Handle case where Unwrap returns []error
+    if (
+      Array.isArray(result) &&
+      result.length > 0 &&
+      result[0] &&
+      typeof result[0].Error === 'function'
+    ) {
+      return result[0]
+    }
+  }
+
+  return null
+}
+
+// Is reports whether any error in err's tree matches target.
+//
+// The tree consists of err itself, followed by the errors obtained by repeatedly
+// calling Unwrap. When err wraps multiple errors, Is examines err followed by a
+// depth-first traversal of its children.
+//
+// An error is considered to match a target if it is equal to that target or if
+// it implements a method Is(error) bool such that Is(target) returns true.
+//
+// An error type might provide an Is method so it can be treated as equivalent
+// to an existing error. For example, if MyError defines
+//
+//	func (m MyError) Is(target error) bool { return target == fs.ErrExist }
+//
+// then Is(MyError{}, fs.ErrExist) returns true. See syscall.Errno.Is for
+// an example in the standard library. An Is method should only shallowly
+// compare err and the target and not call Unwrap on either.
+export function Is(err: $.GoError, target: $.GoError): boolean {
+  if (target === null) {
+    return err === null
+  }
+
+  if (err === null) {
+    return false
+  }
+
+  // Check direct equality
+  if (err === target) {
+    return true
+  }
+
+  // Check if error messages are the same
+  if (err.Error() === target.Error()) {
+    return true
+  }
+
+  // Check if err has an Is method
+  if (typeof (err as any).Is === 'function') {
+    if ((err as any).Is(target)) {
+      return true
+    }
+  }
+
+  // Recursively check wrapped errors
+  const unwrapped = Unwrap(err)
+  if (unwrapped !== null) {
+    return Is(unwrapped, target)
+  }
+
+  // Handle multiple wrapped errors
+  if (typeof (err as any).Unwrap === 'function') {
+    const result = (err as any).Unwrap()
+    if (Array.isArray(result)) {
+      for (const wrappedErr of result) {
+        if (
+          wrappedErr &&
+          typeof wrappedErr.Error === 'function' &&
+          Is(wrappedErr, target)
+        ) {
+          return true
+        }
+      }
+    }
+  }
+
+  return false
+}
+
+// As finds the first error in err's tree that matches target, and if one is found,
+// sets target to that error value and returns true. Otherwise, it returns false.
+//
+// The tree consists of err itself, followed by the errors obtained by repeatedly
+// calling Unwrap. When err wraps multiple errors, As examines err followed by a
+// depth-first traversal of its children.
+//
+// An error matches target if the error's concrete value is assignable to the value
+// pointed to by target, or if the error has a method As(interface{}) bool such that
+// As(target) returns true. In the latter case, the As method is responsible for
+// setting target.
+//
+// An error type might provide an As method so it can be treated as if it were a
+// different error type.
+//
+// As panics if target is not a non-nil pointer to either a type that implements
+// error, or to any interface type.
+export function As(err: $.GoError, target: any): boolean {
+  if (err === null) {
+    return false
+  }
+
+  if (target === null || typeof target !== 'object') {
+    throw new Error('errors: target cannot be nil')
+  }
+
+  // Check if err matches target type
+  if (err.constructor === target.constructor) {
+    // Copy properties from err to target
+    Object.assign(target, err)
+    return true
+  }
+
+  // Check if err has an As method
+  if (typeof (err as any).As === 'function') {
+    if ((err as any).As(target)) {
+      return true
+    }
+  }
+
+  // Recursively check wrapped errors
+  const unwrapped = Unwrap(err)
+  if (unwrapped !== null) {
+    return As(unwrapped, target)
+  }
+
+  // Handle multiple wrapped errors
+  if (typeof (err as any).Unwrap === 'function') {
+    const result = (err as any).Unwrap()
+    if (Array.isArray(result)) {
+      for (const wrappedErr of result) {
+        if (
+          wrappedErr &&
+          typeof wrappedErr.Error === 'function' &&
+          As(wrappedErr, target)
+        ) {
+          return true
+        }
+      }
+    }
+  }
+
+  return false
+}
+
+// Join returns an error that wraps the given errors.
+// Any nil error values are discarded.
+// Join returns nil if every value in errs is nil.
+// The error formats as the concatenation of the strings obtained
+// by calling the Error method of each element of errs, with a newline
+// between each string.
+//
+// A non-nil error returned by Join implements the Unwrap() []error method.
+export function Join(...errs: $.GoError[]): $.GoError {
+  const nonNilErrs = errs.filter((err) => err !== null)
+
+  if (nonNilErrs.length === 0) {
+    return null
+  }
+
+  if (nonNilErrs.length === 1) {
+    return nonNilErrs[0]
+  }
+
+  const message = nonNilErrs.map((err) => err!.Error()).join('\n')
+  const joinedError = new GoScriptError(message)
+
+  // Add Unwrap method that returns the array of errors
+  ;(joinedError as any).Unwrap = function (): $.GoError[] {
+    return nonNilErrs
+  }
+
+  return joinedError
+}

package/gs/errors/godoc.txt

@@ -0,0 +1,63 @@
+package errors // import "errors"
+
+Package errors implements functions to manipulate errors.
+
+The New function creates errors whose only content is a text message.
+
+An error e wraps another error if e's type has one of the methods
+
+    Unwrap() error
+    Unwrap() []error
+
+If e.Unwrap() returns a non-nil error w or a slice containing w, then we say
+that e wraps w. A nil error returned from e.Unwrap() indicates that e does
+not wrap any error. It is invalid for an Unwrap method to return an []error
+containing a nil error value.
+
+An easy way to create wrapped errors is to call fmt.Errorf and apply the %w verb
+to the error argument:
+
+    wrapsErr := fmt.Errorf("... %w ...", ..., err, ...)
+
+Successive unwrapping of an error creates a tree. The Is and As functions
+inspect an error's tree by examining first the error itself followed by the tree
+of each of its children in turn (pre-order, depth-first traversal).
+
+See https://go.dev/blog/go1.13-errors for a deeper discussion of the philosophy
+of wrapping and when to wrap.
+
+Is examines the tree of its first argument looking for an error that matches the
+second. It reports whether it finds a match. It should be used in preference to
+simple equality checks:
+
+    if errors.Is(err, fs.ErrExist)
+
+is preferable to
+
+    if err == fs.ErrExist
+
+because the former will succeed if err wraps io/fs.ErrExist.
+
+As examines the tree of its first argument looking for an error that can be
+assigned to its second argument, which must be a pointer. If it succeeds, it
+performs the assignment and returns true. Otherwise, it returns false. The form
+
+    var perr *fs.PathError
+    if errors.As(err, &perr) {
+    	fmt.Println(perr.Path)
+    }
+
+is preferable to
+
+    if perr, ok := err.(*fs.PathError); ok {
+    	fmt.Println(perr.Path)
+    }
+
+because the former will succeed if err wraps an *io/fs.PathError.
+
+var ErrUnsupported = New("unsupported operation")
+func As(err error, target any) bool
+func Is(err, target error) bool
+func Join(errs ...error) error
+func New(text string) error
+func Unwrap(err error) error

package/gs/errors/index.ts

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

package/gs/internal/goarch/godoc.txt

@@ -0,0 +1,39 @@
+package goarch // import "internal/goarch"
+
+package goarch contains GOARCH-specific constants.
+
+const BigEndian = IsArmbe|IsArm64be|IsMips|IsMips64|IsPpc|IsPpc64|IsS390|IsS390x|IsSparc|IsSparc64 == 1
+const DefaultPhysPageSize = _DefaultPhysPageSize
+const GOARCH = `arm64`
+const Int64Align = PtrSize
+const Is386 = 0
+const IsAmd64 = 0
+const IsAmd64p32 = 0
+const IsArm = 0
+const IsArm64 = 1
+const IsArm64be = 0
+const IsArmbe = 0
+const IsLoong64 = 0
+const IsMips = 0
+const IsMips64 = 0
+const IsMips64le = 0
+const IsMips64p32 = 0
+const IsMips64p32le = 0
+const IsMipsle = 0
+const IsPpc = 0
+const IsPpc64 = 0
+const IsPpc64le = 0
+const IsRiscv = 0
+const IsRiscv64 = 0
+const IsS390 = 0
+const IsS390x = 0
+const IsSparc = 0
+const IsSparc64 = 0
+const IsWasm = 0
+const MinFrameSize = _MinFrameSize
+const PCQuantum = _PCQuantum
+const PtrSize = 4 << (^uintptr(0) >> 63)
+const StackAlign = _StackAlign
+type ArchFamilyType int
+    const AMD64 ArchFamilyType = iota ...
+    const ArchFamily ArchFamilyType = _ArchFamily

package/gs/internal/goarch/index.ts

@@ -0,0 +1,18 @@
+// Architecture constants for JavaScript/WebAssembly target
+// This replaces the auto-generated version with appropriate values for JS
+
+// Pointer size in bytes (64-bit in modern JavaScript environments)
+export const PtrSize = 8
+
+// JavaScript is little-endian
+export const BigEndian = false
+
+// Architecture family
+export const ArchFamily = 'wasm'
+
+// Other common architecture constants
+export const Int64Align = 8
+export const MinFrameSize = 0
+
+// CPU cache line size (not really applicable in JS, but some code might reference it)
+export const CacheLineSize = 64

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}
+)