typenative 0.1.2 → 0.2.0

package/bin/go/convert.js

@@ -0,0 +1,238 @@
+// Go bridge conversions: TypeScript values ↔ Go values at the boundary.
+//
+// toGo(expr, fromType, toType): wraps an already-visited Go expression so it
+// has the target Go type (int(x), T(x), tnGoNums[T](x), ...).
+// fromGo(expr, goType): wraps a Go expression so it reads as a TS number
+// (float64(x)) where needed.
+//
+// Kept in a plain style because this file is part of the self-hosted
+// compiler and must transpile with TypeNative.
+import { goTypeInfo, isGoNumeric, allGoPaths } from './metadata.js';
+let convertServices = {
+    pkg: (_name) => { },
+    helper: (_id) => { },
+    typeOf: (_node) => '',
+    localType: (goType) => goType
+};
+let convertKnownPaths = {};
+export function initConvertPaths() {
+    convertKnownPaths = {};
+    for (const p of allGoPaths())
+        convertKnownPaths[p] = true;
+}
+// Import the package named by a Go type when it is emitted into code.
+function ensureTypePackage(goType) {
+    if (!goType)
+        return;
+    const cleaned = goType.replace(/\[[^\]]*\]/g, ' ').replace(/[*,{}()]/g, ' ');
+    for (const part of cleaned.split(/\s+/)) {
+        if (!part || part === 'error' || part === 'any' || part === 'interface{}')
+            continue;
+        const dot = part.lastIndexOf('.');
+        if (dot < 0)
+            continue;
+        const path = part.slice(0, dot);
+        if (convertKnownPaths[path])
+            convertServices.pkg(path);
+    }
+}
+export function bindConvertServices(s) {
+    convertServices = s;
+}
+// Base name of a Go type: strips pointers, qualifiers and generic args.
+export function goBaseName(goType) {
+    let base = goType;
+    while (base.startsWith('*'))
+        base = base.slice(1);
+    const dot = base.lastIndexOf('.');
+    if (dot >= 0)
+        base = base.slice(dot + 1);
+    const bracket = base.indexOf('[');
+    if (bracket >= 0)
+        base = base.slice(0, bracket);
+    return base;
+}
+// Whether the Go type is a plain (unnamed) integer kind.
+export function isGoIntKind(goType) {
+    const base = goBaseName(goType);
+    return (base === 'int' || base === 'int8' || base === 'int16' || base === 'int32' || base === 'int64' ||
+        base === 'uint' || base === 'uint8' || base === 'uint16' || base === 'uint32' || base === 'uint64' ||
+        base === 'uintptr' || base === 'byte' || base === 'rune');
+}
+// Whether the Go type is a plain float kind.
+export function isGoFloatKind(goType) {
+    const base = goBaseName(goType);
+    return base === 'float32' || base === 'float64';
+}
+// Whether the Go type is a basic kind (never has fields).
+export function isGoBasicKind(goType) {
+    let base = goType;
+    while (base.startsWith('*'))
+        base = base.slice(1);
+    if (base.indexOf('.') >= 0)
+        return false;
+    const bare = base.indexOf('[') >= 0 ? base.slice(0, base.indexOf('[')) : base;
+    return (bare === 'string' || bare === 'bool' ||
+        bare === 'int' || bare === 'int8' || bare === 'int16' || bare === 'int32' || bare === 'int64' ||
+        bare === 'uint' || bare === 'uint8' || bare === 'uint16' || bare === 'uint32' || bare === 'uint64' ||
+        bare === 'uintptr' || bare === 'float32' || bare === 'float64' || bare === 'byte' || bare === 'rune');
+}
+// Whether the Go type is any numeric kind (plain or named).
+export function isGoNumericKind(goType) {
+    if (isGoIntKind(goType) || isGoFloatKind(goType))
+        return true;
+    return isGoNumeric(goType);
+}
+// Convert an already-visited expression to the target Go type. toType is
+// fully qualified (metadata lookups need the path); emitted type names are
+// localized.
+export function toGo(expr, fromType, toType) {
+    if (!toType || toType === 'interface{}' || toType === 'any' || fromType === toType)
+        return expr;
+    if (expr === 'nil')
+        return expr;
+    // Array references read as the slice they point to.
+    if (fromType.startsWith('*[]'))
+        fromType = fromType.slice(1);
+    // Named numeric target: T(x).
+    if (isGoNumeric(toType) && !isGoNumericKind(fromType)) {
+        ensureTypePackage(toType);
+        return `${convertServices.localType(toType)}(${expr})`;
+    }
+    if (isGoNumeric(toType) && isGoNumericKind(fromType) && fromType !== toType) {
+        ensureTypePackage(toType);
+        return `${convertServices.localType(toType)}(${expr})`;
+    }
+    // Plain int target from a TS number: T(x) with the exact kind.
+    if (isGoIntKind(toType) && fromType === 'float64') {
+        return `${goBaseName(toType)}(${expr})`;
+    }
+    if (isGoIntKind(toType) && isGoFloatKind(fromType)) {
+        return `${convertServices.localType(toType)}(${expr})`;
+    }
+    // Named numeric from a plain int kind.
+    if (isGoNumeric(toType) && (isGoIntKind(fromType) || isGoFloatKind(fromType))) {
+        ensureTypePackage(toType);
+        return `${convertServices.localType(toType)}(${expr})`;
+    }
+    // Fixed arrays [N]T → slice when the target is a slice. Call results
+    // are unaddressable, so always go through a temp variable.
+    if (fromType.startsWith('[') && !fromType.startsWith('[]') && toType.startsWith('[]')) {
+        const close = fromType.indexOf(']');
+        const fromElem = close >= 0 ? fromType.slice(close + 1) : '';
+        const toElem = toType.slice(2);
+        if (fromElem === toElem || ((fromElem === 'byte' || fromElem === 'uint8') && (toElem === 'byte' || toElem === 'uint8'))) {
+            return `func() ${convertServices.localType(toType)} { __v := ${expr}; return __v[:] }()`;
+        }
+        if (isGoNumericKind(toElem)) {
+            convertServices.helper('goNums');
+            return `func() ${convertServices.localType(toType)} { __v := ${expr}; return tnGoNums[${convertServices.localType(toElem)}](__v[:]) }()`;
+        }
+        return `func() ${convertServices.localType(toType)} { __v := ${expr}; return __v[:] }()`;
+    }
+    // Slices of numbers: tnGoNums[T](x) / element conversion.
+    // []byte ↔ []byte passes through (Uint8Array needs no conversion).
+    if (toType.startsWith('[]') && fromType.startsWith('[]')) {
+        const toElem = toType.slice(2);
+        const fromElem = fromType.slice(2);
+        if (toElem === fromElem)
+            return expr;
+        if ((toElem === 'byte' || toElem === 'uint8') && (fromElem === 'byte' || fromElem === 'uint8')) {
+            return expr;
+        }
+        if (isGoNumericKind(toElem)) {
+            convertServices.helper('goNums');
+            return `tnGoNums[${convertServices.localType(toElem)}](${expr})`;
+        }
+    }
+    // Untyped constants arrive as float64: convert to the target.
+    if (fromType === 'float64' && isGoNumericKind(toType)) {
+        ensureTypePackage(toType);
+        return `${convertServices.localType(toType)}(${expr})`;
+    }
+    // String target.
+    if (toType === 'string' && fromType !== 'string') {
+        return `string(${expr})`;
+    }
+    // interface{}/any to a concrete named type: type assertion.
+    if ((fromType === 'interface{}' || fromType === 'any' || fromType === '') && !isGoNumericKind(toType)) {
+        const base = goBaseName(toType);
+        if (base && base !== 'string' && base !== 'bool' && base !== 'float64' && !toType.startsWith('[]') && !toType.startsWith('map[') && !toType.startsWith('func(') && !toType.startsWith('chan ') && toType !== 'any' && toType !== 'interface{}') {
+            ensureTypePackage(toType);
+            return `${expr}.(${convertServices.localType(toType)})`;
+        }
+    }
+    // Struct value to pointer slot: take address. Never dereference into
+    // an interface slot (pointer-receiver methods would be lost).
+    if (toType.startsWith('*') && !fromType.startsWith('*') && !fromType.startsWith('[]') && fromType !== 'string' && fromType !== 'float64' && fromType !== 'bool' && fromType !== 'interface{}' && fromType !== 'any') {
+        return `&(${expr})`;
+    }
+    // Single-char string to byte/rune (strconv.FormatFloat 'f', unicode funcs).
+    if ((toType === 'byte' || toType === 'uint8') && fromType === 'string') {
+        return `${expr}[0]`;
+    }
+    if (toType === 'rune' && fromType === 'string') {
+        convertServices.helper('goStrings');
+        return `tnGoRune(${expr})`;
+    }
+    return expr;
+}
+// Convert a Go expression back to a TS-facing value.
+export function fromGo(expr, goType) {
+    if (!goType)
+        return expr;
+    // Named numerics and plain non-float numbers read as TS numbers.
+    if (isGoNumeric(goType) && goType !== 'float64') {
+        return `float64(${expr})`;
+    }
+    if (isGoIntKind(goType) && goType !== 'float64') {
+        return `float64(${expr})`;
+    }
+    if (isGoFloatKind(goType) && goType !== 'float64') {
+        return `float64(${expr})`;
+    }
+    // Slices of numbers read back as []float64 ([]byte stays []byte).
+    if (goType.startsWith('[]')) {
+        const elem = goType.slice(2);
+        if ((elem === 'byte' || elem === 'uint8'))
+            return expr;
+        if (isGoNumericKind(elem) && elem !== 'float64') {
+            convertServices.helper('goNums');
+            return `tnGoFromNums[${elem}](${expr})`;
+        }
+    }
+    return expr;
+}
+// Wrap a (T, error) or (A, B, error) call so it throws on error.
+export function mustCall(expr, resultCount) {
+    if (resultCount === 1) {
+        convertServices.helper('goMust');
+        return `tnGoMust(${expr})`;
+    }
+    if (resultCount === 2) {
+        convertServices.helper('goMust');
+        return `tnGoMust2(${expr})`;
+    }
+    return expr;
+}
+// Wrap an error-only call so it throws on error.
+export function checkCall(expr) {
+    convertServices.helper('goMust');
+    return `tnGoCheck(${expr})`;
+}
+// Whether the expression needs no conversion (already the target type).
+export function needsConversion(fromType, toType) {
+    if (!toType || toType === 'interface{}' || toType === 'any')
+        return false;
+    if (fromType === toType)
+        return false;
+    if (isGoNumericKind(toType) && fromType === 'float64')
+        return true;
+    if (toType.startsWith('[]') && fromType.startsWith('[]')) {
+        return toType.slice(2) !== fromType.slice(2);
+    }
+    return false;
+}
+export function goTypeInfoRef(goType) {
+    return goTypeInfo(goType);
+}

package/bin/go/metadata.js

@@ -0,0 +1,211 @@
+// Go bridge metadata: parses one package string from stdlib.generated.ts
+// into GoPackageInfo. Parsed only for imported packages and cached per run.
+//
+// Kept in a plain style (records of closures, positional helpers) because
+// this file is part of the self-hosted compiler and must transpile with
+// TypeNative.
+import { goStdlib } from './stdlib.generated.js';
+const packageCache = {};
+function unesc(s) {
+    let out = '';
+    for (let i = 0; i < s.length; i++) {
+        if (s[i] === '\\' && i + 1 < s.length) {
+            const next = s[i + 1];
+            if (next === 'n') {
+                out += '\n';
+                i++;
+            }
+            else if (next === 'p') {
+                out += '|';
+                i++;
+            }
+            else if (next === '\\') {
+                out += '\\';
+                i++;
+            }
+            else {
+                out += s[i];
+            }
+        }
+        else {
+            out += s[i];
+        }
+    }
+    return out;
+}
+function splitTop(s) {
+    const out = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (ch === '[' || ch === '(' || ch === '{')
+            depth++;
+        else if (ch === ']' || ch === ')' || ch === '}')
+            depth--;
+        else if (ch === ',' && depth === 0) {
+            out.push(s.slice(start, i));
+            start = i + 1;
+        }
+    }
+    out.push(s.slice(start));
+    return out;
+}
+function parseParams(s) {
+    const out = [];
+    if (!s)
+        return out;
+    for (const part of splitTop(s)) {
+        const space = part.indexOf(' ');
+        if (space < 0)
+            continue;
+        out.push({ name: unesc(part.slice(0, space)), goType: unesc(part.slice(space + 1)) });
+    }
+    return out;
+}
+function parseResults(s) {
+    if (!s)
+        return [];
+    return splitTop(s).map((r) => unesc(r));
+}
+// The metadata of one Go package, parsed on demand and cached.
+export function goPackage(path) {
+    if (path in packageCache)
+        return packageCache[path];
+    const raw = goStdlib[path];
+    if (raw === undefined) {
+        packageCache[path] = null;
+        return null;
+    }
+    const info = { path, name: path, funcs: {}, types: {}, consts: {}, vars: {} };
+    for (const line of raw.split('\n')) {
+        if (!line)
+            continue;
+        const kind = line[0];
+        const body = line.slice(1);
+        if (kind === 'P') {
+            info.name = unesc(body);
+        }
+        else if (kind === 'F') {
+            const parts = body.split('|');
+            const name = unesc(parts[0] ?? '');
+            info.funcs[name] = {
+                name,
+                tparams: parts[1] ? unesc(parts[1]).split(',') : [],
+                tcores: parts[5] ? unesc(parts[5]).split(';') : [],
+                params: parseParams(parts[2] ?? ''),
+                results: parseResults(parts[3] ?? ''),
+                variadic: (parts[4] ?? '') === 'true'
+            };
+        }
+        else if (kind === 'T') {
+            const parts = body.split('|');
+            const name = unesc(parts[0] ?? '');
+            info.types[name] = {
+                name,
+                kind: unesc(parts[1] ?? ''),
+                under: unesc(parts[2] ?? ''),
+                tparams: parts[3] ? unesc(parts[3]).split(',') : [],
+                numeric: (parts[4] ?? '') === 'true',
+                fields: [],
+                methods: [],
+                ifaceMethods: []
+            };
+        }
+        else if (kind === 'f') {
+            const parts = body.split('|');
+            const typeName = unesc(parts[0] ?? '');
+            const type = info.types[typeName];
+            if (type)
+                type.fields.push({ name: unesc(parts[1] ?? ''), goType: unesc(parts[2] ?? '') });
+        }
+        else if (kind === 'M') {
+            const parts = body.split('|');
+            const typeName = unesc(parts[0] ?? '');
+            const type = info.types[typeName];
+            if (type) {
+                type.methods.push({
+                    name: unesc(parts[1] ?? ''),
+                    ptr: (parts[2] ?? '') === 'true',
+                    params: parseParams(parts[3] ?? ''),
+                    results: parseResults(parts[4] ?? '')
+                });
+            }
+        }
+        else if (kind === 'I') {
+            const parts = body.split('|');
+            const typeName = unesc(parts[0] ?? '');
+            const type = info.types[typeName];
+            if (type) {
+                type.ifaceMethods.push({
+                    name: unesc(parts[1] ?? ''),
+                    ptr: false,
+                    params: parseParams(parts[2] ?? ''),
+                    results: parseResults(parts[3] ?? '')
+                });
+            }
+        }
+        else if (kind === 'C') {
+            const parts = body.split('|');
+            const name = unesc(parts[0] ?? '');
+            info.consts[name] = { name, kind: unesc(parts[1] ?? ''), goType: unesc(parts[2] ?? '') };
+        }
+        else if (kind === 'V') {
+            const parts = body.split('|');
+            const name = unesc(parts[0] ?? '');
+            info.vars[name] = { name, goType: unesc(parts[1] ?? '') };
+        }
+    }
+    packageCache[path] = info;
+    return info;
+}
+// Whether a package path has bridge metadata.
+export function hasGoPackage(path) {
+    return goStdlib[path] !== undefined;
+}
+// All known package paths (for resolving cross-package type references).
+export function allGoPaths() {
+    return Object.keys(goStdlib);
+}
+// Resolve a qualified Go type to its type info.
+export function goTypeInfo(goType) {
+    let base = goType;
+    while (base.startsWith('*'))
+        base = base.slice(1);
+    const dot = base.lastIndexOf('.');
+    if (dot < 0)
+        return null;
+    const path = base.slice(0, dot);
+    let name = base.slice(dot + 1);
+    const bracket = name.indexOf('[');
+    if (bracket >= 0)
+        name = name.slice(0, bracket);
+    const info = goPackage(path);
+    if (!info)
+        return null;
+    const type = info.types[name] ?? null;
+    // Aliases of named types resolve to the target (os.FileMode = fs.FileMode).
+    if (type && type.kind === 'alias' && type.under && type.under !== goType && type.under.indexOf('.') >= 0) {
+        const target = goTypeInfo(type.under);
+        if (target)
+            return target;
+    }
+    return type;
+}
+// Whether the Go type is a named numeric (time.Duration, fs.FileMode).
+export function isGoNumeric(goType) {
+    const info = goTypeInfo(goType);
+    return !!info && info.kind === 'basic' && info.numeric;
+}
+// Canonical form of a struct type: pointer when it has any pointer-receiver
+// method, value otherwise.
+export function goCanonical(typeName, info) {
+    const type = info.types[typeName];
+    if (!type)
+        return typeName;
+    for (const m of type.methods) {
+        if (m.ptr)
+            return '*' + typeName;
+    }
+    return typeName;
+}

package/bin/go/overrides.js

@@ -0,0 +1,68 @@
+// Go bridge overrides: hand-written exceptions keyed 'pkg.Func'.
+// This is the only hand-maintained per-package data.
+//
+// sync: callbacks listed here run synchronously on the caller, so a TS
+// closure can be invoked directly. Anything else taking a callback is
+// wrapped in TnLoopCall.
+// blocking: calls that block (network, sleep, wait) run on a goroutine
+// while the baton holder pumps TnLoopRunPending.
+// excluded: packages with no bridge and the reason why.
+export const goOverrides = {
+    'sort.Slice': { sync: true },
+    'sort.SliceStable': { sync: true },
+    'sort.SliceIsSorted': { sync: true },
+    'slices.SortFunc': { sync: true },
+    'slices.SortStableFunc': { sync: true },
+    'slices.IsSortedFunc': { sync: true },
+    'slices.BinarySearchFunc': { sync: true },
+    'slices.CompareFunc': { sync: true },
+    'slices.MinFunc': { sync: true },
+    'slices.MaxFunc': { sync: true },
+    'maps.Keys': { sync: true },
+    'maps.Values': { sync: true },
+    'maps.All': { sync: true },
+    'strings.Map': { sync: true },
+    'strings.ReplaceAll': { sync: true },
+    'bytes.Map': { sync: true },
+    'path/filepath.Walk': { sync: true },
+    'path/filepath.WalkDir': { sync: true },
+    'time.AfterFunc': { sync: true },
+    'time.Sleep': { blocking: true },
+    'net/http.ListenAndServe': { blocking: true },
+    'net/http.Serve': { blocking: true },
+    'net.Accept': { blocking: true },
+    'os/exec.Wait': { blocking: true },
+    'sync.WaitGroup.Wait': { blocking: true }
+};
+// Import-path → emitted qualifier for packages whose name collides with
+// another importable package (or a common variable name). Single source of
+// truth: the transpiler's goImportLine and the bridge qualifier use it.
+export const goPathAliases = {
+    'math/big': 'tnbig',
+    crypto: 'tncrypto',
+    'net/url': 'tnurl',
+    'crypto/rand': 'cryptorand',
+    'math/rand/v2': 'randv2',
+    'html/template': 'htmltemplate',
+    'golang.org/x/text/unicode/norm': 'tnnorm',
+    // node:sqlite's driver: the package name differs from the last path element
+    'github.com/ncruces/go-sqlite3': 'sqlite3'
+};
+export const goExcluded = {
+    plugin: 'cgo, `-buildmode=plugin`',
+    unsafe: 'raw pointers',
+    'runtime/race': 'needs `-race`',
+    'runtime/coverage': 'needs `-cover`',
+    'runtime/cgo': 'needs cgo',
+    embed: 'needs a `//go:embed` directive; a later phase'
+};
+// Whether a call taking a callback invokes it synchronously.
+export function isSyncCallback(pkgPath, funcName) {
+    const override = goOverrides[`${pkgPath}.${funcName}`];
+    return !!override && override.sync === true;
+}
+// Whether a call blocks and needs the goroutine wrapper.
+export function isBlockingCall(pkgPath, funcName) {
+    const override = goOverrides[`${pkgPath}.${funcName}`];
+    return !!override && override.blocking === true;
+}