goscript 0.1.4 → 0.2.1

package/gs/runtime/trace/index.test.ts

@@ -27,7 +27,7 @@ describe('runtime/trace override', () => {
     expect(called.value).toBe(true)
   })
 
-  it('writes deterministic trace bytes', () => {
+  it('reports execution tracing as unsupported', () => {
     const chunks: Uint8Array[] = []
     const writer = {
       Write(p: Uint8Array): [number, null] {
@@ -36,10 +36,12 @@ describe('runtime/trace override', () => {
       },
     }
 
-    expect(Start(writer)).toBeNull()
+    expect(Start(writer)?.Error()).toBe(
+      'runtime/trace: execution tracing is unsupported in GoScript',
+    )
     Log(context.Background(), 'category', 'message')
     Stop()
 
-    expect(chunks.reduce((total, chunk) => total + chunk.length, 0)).toBeGreaterThan(0)
+    expect(chunks).toHaveLength(0)
   })
 })

package/gs/runtime/trace/index.ts

@@ -6,10 +6,13 @@ import * as io from '@goscript/io/index.js'
 class traceContextKey {}
 
 const traceState = {
-  activeWriter: null as io.Writer | null,
   nextTaskID: 0,
 }
 
+const unsupportedTraceError = errors.New(
+  'runtime/trace: execution tracing is unsupported in GoScript',
+)
+
 export class Task {
   public id: number
 
@@ -41,7 +44,8 @@ export function NewTask(
 }
 
 export function Log(_ctx: context.Context | null, category: string, message: string): void {
-  writeTrace(`log ${category} ${message}\n`)
+  void category
+  void message
 }
 
 export function Logf(
@@ -75,23 +79,7 @@ export function Start(w: io.Writer | $.VarRef<io.Writer> | null): $.GoError {
   if (writer == null) {
     return errors.New('runtime/trace: nil trace writer')
   }
-  if (traceState.activeWriter != null) {
-    return errors.New('runtime/trace: trace already active')
-  }
-  traceState.activeWriter = writer
-  return writeTrace('goscript trace start\n')
-}
-
-export function Stop(): void {
-  writeTrace('goscript trace stop\n')
-  traceState.activeWriter = null
+  return unsupportedTraceError
 }
 
-function writeTrace(text: string): $.GoError {
-  const writer = traceState.activeWriter
-  if (writer == null) {
-    return null
-  }
-  const [, err] = writer.Write($.stringToBytes(text))
-  return err
-}
+export function Stop(): void {}

package/gs/runtime/trace/parity.json

@@ -0,0 +1,36 @@
+{
+  "schemaVersion": 1,
+  "strict": false,
+  "symbols": {
+    "IsEnabled": {
+      "status": "real"
+    },
+    "Log": {
+      "status": "real"
+    },
+    "Logf": {
+      "status": "real"
+    },
+    "NewTask": {
+      "status": "real"
+    },
+    "Region": {
+      "status": "real"
+    },
+    "Start": {
+      "status": "real"
+    },
+    "StartRegion": {
+      "status": "real"
+    },
+    "Stop": {
+      "status": "real"
+    },
+    "Task": {
+      "status": "real"
+    },
+    "WithRegion": {
+      "status": "real"
+    }
+  }
+}

package/gs/strconv/atoi.gs.ts

@@ -68,7 +68,7 @@ export class NumError {
 		new NumError(),
 		[{ 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' } }] }] } }] }],
 		NumError,
-		{"Func": { kind: $.TypeKind.Basic, name: "string" }, "Num": { kind: $.TypeKind.Basic, name: "string" }, "Err": { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] }}
+		[{ name: "Func", key: "Func", type: { kind: $.TypeKind.Basic, name: "string" } }, { name: "Num", key: "Num", type: { kind: $.TypeKind.Basic, name: "string" } }, { name: "Err", key: "Err", type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }]
 	);
 }
 

package/gs/strconv/complex.gs.ts

@@ -0,0 +1,174 @@
+import * as $ from '@goscript/builtin/index.js'
+import { FormatFloat } from './ftoa.gs.js'
+import { ParseFloat } from './atof.gs.js'
+import { ErrRange, ErrSyntax, NumError } from './atoi.gs.js'
+
+export function FormatComplex(
+  c: $.Complex,
+  fmt: number,
+  prec: number,
+  bitSize: number,
+): string {
+  const real = FormatFloat($.real(c), fmt, prec, bitSize / 2)
+  const imag = $.imag(c)
+  const imagText = FormatFloat(Math.abs(imag), fmt, prec, bitSize / 2)
+  const sign = imag < 0 || Object.is(imag, -0) ? '-' : '+'
+  return `(${real}${sign}${imagText}i)`
+}
+
+export function ParseComplex(
+  s: string,
+  bitSize: number,
+): [$.Complex, $.GoError] {
+  if (/\s/.test(s)) {
+    return [$.complex(0, 0), complexSyntaxError(s)]
+  }
+  const text = s
+  if (text.startsWith('(') !== text.endsWith(')')) {
+    return [$.complex(0, 0), complexSyntaxError(s)]
+  }
+  const inner =
+    text.startsWith('(') && text.endsWith(')') ? text.slice(1, -1) : text
+  if (inner === '') {
+    return [$.complex(0, 0), complexSyntaxError(s)]
+  }
+  if (!inner.endsWith('i')) {
+    const [real, err] = parseComplexFloat(inner, bitSize)
+    if (err !== null) {
+      return [$.complex(isRangeError(err) ? real : 0, 0), complexError(s, err)]
+    }
+    return [$.complex(real, 0), null]
+  }
+
+  const body = inner.slice(0, -1)
+  if (body === '' || body === '+' || body === '-') {
+    return [$.complex(0, 0), complexSyntaxError(s)]
+  }
+  const [pureImag, pureImagErr] = parseComplexFloat(body, bitSize)
+  if (pureImagErr === null) {
+    return [$.complex(0, pureImag), null]
+  }
+  if (isRangeError(pureImagErr)) {
+    return [$.complex(0, pureImag), complexRangeError(s)]
+  }
+
+  const split = splitComplexParts(body, bitSize)
+  if (split === null) {
+    return [$.complex(0, 0), complexSyntaxError(s)]
+  }
+  const [realText, imagText] = split
+  const [real, realErr] = parseComplexFloat(realText, bitSize)
+  if (realErr !== null) {
+    return [$.complex(isRangeError(realErr) ? real : 0, 0), complexError(s, realErr)]
+  }
+  const [imag, imagErr] = parseComplexFloat(imagText, bitSize)
+  if (imagErr !== null) {
+    return [$.complex(real, isRangeError(imagErr) ? imag : 0), complexError(s, imagErr)]
+  }
+  return [$.complex(real, imag), null]
+}
+
+function splitComplexParts(body: string, bitSize: number): [string, string] | null {
+  for (let i = body.length - 1; i > 0; i--) {
+    const char = body[i]
+    if (
+      (char === '+' || char === '-') &&
+      body[i - 1] !== 'e' &&
+      body[i - 1] !== 'E' &&
+      body[i - 1] !== 'p' &&
+      body[i - 1] !== 'P'
+    ) {
+      const realText = body.slice(0, i)
+      const imagText = body.slice(i)
+      if (complexPartsParse(realText, imagText, bitSize)) {
+        return [realText, imagText]
+      }
+      if (char === '+' && body[i + 1] === '-' && complexPartsParse(realText, body.slice(i + 1), bitSize)) {
+        return [realText, body.slice(i + 1)]
+      }
+    }
+  }
+  return null
+}
+
+function complexPartsParse(realText: string, imagText: string, bitSize: number): boolean {
+  const [, realErr] = parseComplexFloat(realText, bitSize)
+  if (realErr !== null) {
+    return false
+  }
+  const [, imagErr] = parseComplexFloat(imagText, bitSize)
+  return imagErr === null
+}
+
+function parseComplexFloat(s: string, bitSize: number): [number, $.GoError] {
+  if (!isComplexFloatLiteral(s)) {
+    return [0, complexSyntaxError(s)]
+  }
+  if (isHexFloatLiteral(s)) {
+    return parseHexFloat(s, bitSize / 2)
+  }
+  const [value, err] = ParseFloat(s, bitSize / 2)
+  if (err !== null) {
+    return [value, err]
+  }
+  if (!Number.isFinite(value) && !/^[+-]?(?:inf(?:inity)?|nan)$/i.test(s)) {
+    return [value, new NumError({ Func: 'ParseFloat', Num: s, Err: ErrRange })]
+  }
+  return [value, null]
+}
+
+function isComplexFloatLiteral(s: string): boolean {
+  return (
+    /^[+-]?(?:(?:inf(?:inity)?)|nan|(?:(?:(?:\d(?:_?\d)*)(?:\.(?:\d(?:_?\d)*)?)?)|(?:\.(?:\d(?:_?\d)*)))(?:[eE][+-]?\d(?:_?\d)*)?)$/i.test(s) ||
+    isHexFloatLiteral(s)
+  )
+}
+
+function isHexFloatLiteral(s: string): boolean {
+  if (!/^[+-]?0[xX]_?(?:(?:[0-9A-Fa-f](?:_?[0-9A-Fa-f])*(?:\.(?:[0-9A-Fa-f](?:_?[0-9A-Fa-f])*)?)?)|(?:\.(?:[0-9A-Fa-f](?:_?[0-9A-Fa-f])*)))[pP][+-]?\d(?:_?\d)*$/.test(s)) {
+    return false
+  }
+  const unsigned = s[0] === '+' || s[0] === '-' ? s.slice(1) : s
+  const marker = unsigned.toLowerCase().indexOf('p')
+  const digits = unsigned.slice(2, marker).replace('.', '').replace(/_/g, '')
+  return /^[0-9A-Fa-f]+$/.test(digits)
+}
+
+function parseHexFloat(s: string, bitSize: number): [number, $.GoError] {
+  const sign = s.startsWith('-') ? -1 : 1
+  const unsigned = s[0] === '+' || s[0] === '-' ? s.slice(1) : s
+  const clean = unsigned.replace(/_/g, '').toLowerCase()
+  const marker = clean.indexOf('p')
+  const mantissa = clean.slice(2, marker)
+  const exponent = Number.parseInt(clean.slice(marker + 1), 10)
+  const [whole, frac = ''] = mantissa.split('.')
+  let value = whole === '' ? 0 : Number.parseInt(whole, 16)
+  for (let i = 0; i < frac.length; i++) {
+    value += Number.parseInt(frac[i], 16) / 16 ** (i + 1)
+  }
+  const parsed = sign * value * 2 ** exponent
+  if (!Number.isFinite(parsed)) {
+    return [parsed, new NumError({ Func: 'ParseFloat', Num: s, Err: ErrRange })]
+  }
+  const maxFloat32 = 3.4028234663852886e38
+  if (bitSize === 32 && Math.abs(parsed) > maxFloat32) {
+    return [parsed > 0 ? Infinity : -Infinity, new NumError({ Func: 'ParseFloat', Num: s, Err: ErrRange })]
+  }
+  return [parsed, null]
+}
+
+function complexSyntaxError(s: string): $.GoError {
+  return new NumError({ Func: 'ParseComplex', Num: s, Err: ErrSyntax })
+}
+
+function complexRangeError(s: string): $.GoError {
+  return new NumError({ Func: 'ParseComplex', Num: s, Err: ErrRange })
+}
+
+function complexError(s: string, err: $.GoError): $.GoError {
+  return isRangeError(err) ? complexRangeError(s) : complexSyntaxError(s)
+}
+
+function isRangeError(err: $.GoError): boolean {
+  return err !== null && err.Error().includes('value out of range')
+}

package/gs/strconv/complex.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import { FormatComplex, ParseComplex } from './complex.gs.js'
+
+describe('strconv complex helpers', () => {
+  it('formats complex values with Go-style parentheses', () => {
+    expect(FormatComplex($.complex(1.5, -2), 'f'.charCodeAt(0), -1, 128)).toBe(
+      '(1.5-2i)',
+    )
+  })
+
+  it('parses signed complex values', () => {
+    const [value, err] = ParseComplex('(1.5-2i)', 128)
+
+    expect(err).toBeNull()
+    expect($.real(value)).toBe(1.5)
+    expect($.imag(value)).toBe(-2)
+  })
+
+  it('parses real, imaginary, parenthesized, and signed imaginary forms', () => {
+    const cases = [
+      ['1', 1, 0],
+      ['(1)', 1, 0],
+      ['1i', 0, 1],
+      ['+1i', 0, 1],
+      ['-1i', 0, -1],
+      ['(1i)', 0, 1],
+      ['1+2i', 1, 2],
+      ['1+-2i', 1, -2],
+      ['1e+2-3i', 100, -3],
+      ['1e-2+3i', 0.01, 3],
+      ['0x1p+2+0x1.8p+1i', 4, 3],
+      ['0x1p-1-0x1p+1i', 0.5, -2],
+      ['0x1.8p+2i', 0, 6],
+      ['0x_3p3i', 0, 24],
+      ['0x_10.3p-8+0x3p3i', 16.1875 / 256, 24],
+    ] as const
+
+    for (const [input, real, imag] of cases) {
+      const [value, err] = ParseComplex(input, 128)
+
+      expect(err, input).toBeNull()
+      expect($.real(value)).toBe(real)
+      expect($.imag(value)).toBe(imag)
+    }
+  })
+
+  it('rejects whitespace and malformed imaginary forms', () => {
+    for (const input of [' 1+2i', '1+2i ', '1 +2i', 'i', '+i', '-i', '1++2i', '1-+2i', '0xp1']) {
+      const [, err] = ParseComplex(input, 128)
+
+      expect(err?.Error(), input).toBe(`strconv.ParseComplex: parsing "${input}": invalid syntax`)
+    }
+  })
+
+  it('reports hexadecimal range errors', () => {
+    const [value, err] = ParseComplex('0x1p1025', 128)
+
+    expect($.real(value)).toBe(Infinity)
+    expect($.imag(value)).toBe(0)
+    expect(err?.Error()).toBe('strconv.ParseComplex: parsing "0x1p1025": value out of range')
+  })
+})

package/gs/strconv/index.ts

@@ -10,6 +10,7 @@ export {
   ParseUint,
 } from './atoi.gs.js'
 export { AppendFloat, FormatFloat } from './ftoa.gs.js'
+export { FormatComplex, ParseComplex } from './complex.gs.js'
 export {
   AppendInt,
   AppendUint,

package/gs/strconv/parity.json

@@ -0,0 +1,120 @@
+{
+  "schemaVersion": 1,
+  "strict": true,
+  "symbols": {
+    "AppendBool": {
+      "status": "real"
+    },
+    "AppendFloat": {
+      "status": "real"
+    },
+    "AppendInt": {
+      "status": "real"
+    },
+    "AppendQuote": {
+      "status": "real"
+    },
+    "AppendQuoteRune": {
+      "status": "real"
+    },
+    "AppendQuoteRuneToASCII": {
+      "status": "real"
+    },
+    "AppendQuoteRuneToGraphic": {
+      "status": "real"
+    },
+    "AppendQuoteToASCII": {
+      "status": "real"
+    },
+    "AppendQuoteToGraphic": {
+      "status": "real"
+    },
+    "AppendUint": {
+      "status": "real"
+    },
+    "Atoi": {
+      "status": "real"
+    },
+    "CanBackquote": {
+      "status": "real"
+    },
+    "ErrRange": {
+      "status": "real"
+    },
+    "ErrSyntax": {
+      "status": "real"
+    },
+    "FormatBool": {
+      "status": "real"
+    },
+    "FormatComplex": {
+      "status": "real"
+    },
+    "FormatFloat": {
+      "status": "real"
+    },
+    "FormatInt": {
+      "status": "real"
+    },
+    "FormatUint": {
+      "status": "real"
+    },
+    "IntSize": {
+      "status": "real"
+    },
+    "IsGraphic": {
+      "status": "real"
+    },
+    "IsPrint": {
+      "status": "real"
+    },
+    "Itoa": {
+      "status": "real"
+    },
+    "NumError": {
+      "status": "real"
+    },
+    "ParseBool": {
+      "status": "real"
+    },
+    "ParseComplex": {
+      "status": "real"
+    },
+    "ParseFloat": {
+      "status": "real"
+    },
+    "ParseInt": {
+      "status": "real"
+    },
+    "ParseUint": {
+      "status": "real"
+    },
+    "Quote": {
+      "status": "real"
+    },
+    "QuotedPrefix": {
+      "status": "real"
+    },
+    "QuoteRune": {
+      "status": "real"
+    },
+    "QuoteRuneToASCII": {
+      "status": "real"
+    },
+    "QuoteRuneToGraphic": {
+      "status": "real"
+    },
+    "QuoteToASCII": {
+      "status": "real"
+    },
+    "QuoteToGraphic": {
+      "status": "real"
+    },
+    "Unquote": {
+      "status": "real"
+    },
+    "UnquoteChar": {
+      "status": "real"
+    }
+  }
+}

package/gs/strings/builder.ts

@@ -231,6 +231,6 @@ export class Builder {
       },
     ],
     Builder,
-    {},
+    [],
   )
 }

package/gs/strings/parity.json

@@ -0,0 +1,186 @@
+{
+  "schemaVersion": 1,
+  "strict": true,
+  "symbols": {
+    "Builder": {
+      "status": "real"
+    },
+    "Clone": {
+      "status": "real"
+    },
+    "Compare": {
+      "status": "real"
+    },
+    "Contains": {
+      "status": "real"
+    },
+    "ContainsAny": {
+      "status": "real"
+    },
+    "ContainsFunc": {
+      "status": "real"
+    },
+    "ContainsRune": {
+      "status": "real"
+    },
+    "Count": {
+      "status": "real"
+    },
+    "Cut": {
+      "status": "real"
+    },
+    "CutPrefix": {
+      "status": "real"
+    },
+    "CutSuffix": {
+      "status": "real"
+    },
+    "EqualFold": {
+      "status": "real"
+    },
+    "Fields": {
+      "status": "real"
+    },
+    "FieldsFunc": {
+      "status": "real"
+    },
+    "FieldsFuncSeq": {
+      "status": "real"
+    },
+    "FieldsSeq": {
+      "status": "real"
+    },
+    "HasPrefix": {
+      "status": "real"
+    },
+    "HasSuffix": {
+      "status": "real"
+    },
+    "Index": {
+      "status": "real"
+    },
+    "IndexAny": {
+      "status": "real"
+    },
+    "IndexByte": {
+      "status": "real"
+    },
+    "IndexFunc": {
+      "status": "real"
+    },
+    "IndexRune": {
+      "status": "real"
+    },
+    "Join": {
+      "status": "real"
+    },
+    "LastIndex": {
+      "status": "real"
+    },
+    "LastIndexAny": {
+      "status": "real"
+    },
+    "LastIndexByte": {
+      "status": "real"
+    },
+    "LastIndexFunc": {
+      "status": "real"
+    },
+    "Lines": {
+      "status": "real"
+    },
+    "Map": {
+      "status": "real"
+    },
+    "NewReader": {
+      "status": "real"
+    },
+    "NewReplacer": {
+      "status": "real"
+    },
+    "Reader": {
+      "status": "real"
+    },
+    "Repeat": {
+      "status": "real"
+    },
+    "Replace": {
+      "status": "real"
+    },
+    "ReplaceAll": {
+      "status": "real"
+    },
+    "Replacer": {
+      "status": "real"
+    },
+    "Split": {
+      "status": "real"
+    },
+    "SplitAfter": {
+      "status": "real"
+    },
+    "SplitAfterN": {
+      "status": "real"
+    },
+    "SplitAfterSeq": {
+      "status": "real"
+    },
+    "SplitN": {
+      "status": "real"
+    },
+    "SplitSeq": {
+      "status": "real"
+    },
+    "Title": {
+      "status": "real"
+    },
+    "ToLower": {
+      "status": "real"
+    },
+    "ToLowerSpecial": {
+      "status": "real"
+    },
+    "ToTitle": {
+      "status": "real"
+    },
+    "ToTitleSpecial": {
+      "status": "real"
+    },
+    "ToUpper": {
+      "status": "real"
+    },
+    "ToUpperSpecial": {
+      "status": "real"
+    },
+    "ToValidUTF8": {
+      "status": "real"
+    },
+    "Trim": {
+      "status": "real"
+    },
+    "TrimFunc": {
+      "status": "real"
+    },
+    "TrimLeft": {
+      "status": "real"
+    },
+    "TrimLeftFunc": {
+      "status": "real"
+    },
+    "TrimPrefix": {
+      "status": "real"
+    },
+    "TrimRight": {
+      "status": "real"
+    },
+    "TrimRightFunc": {
+      "status": "real"
+    },
+    "TrimSpace": {
+      "status": "real"
+    },
+    "TrimSuffix": {
+      "status": "real"
+    }
+  }
+}