typenative 0.0.21 → 0.1.1

package/.github/workflows/ci.yml

@@ -0,0 +1,29 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  conformance:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: npm
+
+      - uses: actions/setup-go@v5
+        with:
+          go-version: '1.23'
+
+      - run: npm ci
+
+      - run: npm run build
+
+      - run: npm ci
+        working-directory: conformance
+
+      - run: npm run conformance

package/.github/workflows/npm-publish-github-packages.yml

@@ -27,11 +27,11 @@ jobs:
           node-version: 24
       - uses: actions/setup-go@v5
         with:
-          go-version: '1.21'
+          go-version: '1.23'
       - run: npm ci
       - run: npm ci
-        working-directory: test
-      - run: npm test
+        working-directory: conformance
+      - run: npm run conformance
 
   release:
     needs: test

package/CHANGELOG.md

@@ -5,6 +5,87 @@ All notable changes to TypeNative will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.1] - 2026-10-10
+
+The conformance suite is fully green: all 147 probes pass (up from 95/147), through both the dev
+CLI (`node bin/cli.js`) and the self-hosted native compiler (`npm run conformance -- --native`).
+
+### Added
+
+- **Language**: array/object destructuring with defaults and elision, computed keys, `for...in`,
+  labeled loops (`continue outer` / `break outer`), `as const`, type guards (`p is T`),
+  generators (`function*` / `yield` / `yield*`) and `*[Symbol.iterator]()` custom iterators,
+  `async`/`await` with `new Promise`, `.then` and `Promise.all` (lowered to goroutines over
+  channels, with pending callbacks and timers drained before exit), `setTimeout`
+- **Modules**: `import.meta.url` — the `file://` URL of the running program
+  (`os.Executable` through the `pathToFileURL` lowering)
+- **Classes**: inheritance with `super` (methods copied onto subclasses for `this` dispatch),
+  abstract classes, `#private` fields, static members typed from initializers, getters/setters
+  (`c.v` reads/writes rewrite to `Get_v()`/`Set_v()`), interface `extends` (inherited properties
+  flattened into the derived struct), object-literal methods and getters
+- **Errors**: `throw new Error` / `new Error(message)` produce a real error value — custom error
+  classes via `extends Error`, `instanceof` and `.message` on caught values
+- **Typing**: generic functions via Go generics (call sites infer type arguments), numeric enums
+  as plain numbers, tagged templates, JS loose equality (`0 == false`) with `bool`/number/string
+  coercion, `p is T` predicates returning `bool`
+- **Runtime values**: `bigint` (`2n ** 64n` etc. via `math/big`) and `symbol` (unique pointers,
+  usable as record keys)
+- **Library**: array `splice`, `fill`, `entries`, `flatMap`, `findLast`/`findLastIndex`,
+  `lastIndexOf`, `new Array<T>(n)`, `Array.from`, `join()` defaulting to `","`, in-place
+  `reverse`; `charCodeAt`/`String.fromCharCode`/`localeCompare`; `Date` (`new Date(ms)`,
+  `getTime`, `toISOString`, `Date.now()`); `Object.assign`; `.length` counts UTF-8 code points
+  and `[...str]` spreads runes
+- **Regex**: `/g` regexes carry `lastIndex` state (`re.exec` loops terminate); named groups
+  (`(?<name>` → `(?P<name>`, `exec` returns a match with `.groups`); backreferences and
+  lookbehind/lookahead run on a small backtracking engine (RE2 does not support them)
+- **Semantics**: arrays are references — `const b = a; b.push(3)` is visible through `a`
+  (array variables hold `*[]T`)
+
+### Changed
+
+- `JSON.stringify` serializes through reflection, so unexported (auto-generated) struct fields
+  are included
+- `Object.assign` copies sources (structs, maps, dynamic objects) into an ordered map
+- `throw` panics with a `TnError` value carrying `.message` instead of a bare string
+
+## [0.1.0] - 2026-10-09
+
+TypeNative compiles itself: `src/main.ts` builds into a native `typenative` binary that passes the
+whole test suite and regenerates its own Go source identically (stage-1/stage-2 bootstrap).
+
+### Added
+
+- **Native compiler**: `npm run build:native` builds `native/typenative` and `native/tsparser`
+- **`any` / `unknown` at runtime**: property and index access, truthiness, equality (objects by
+  identity), method calls, spreads and conversions to typed values via a small Go runtime
+  (`TnGet`, `TnSet`, `TnAs`, …) — no guessed types
+- **Language**: object spread, `??=`, `in`, `typeof`, `continue`, optional and destructured
+  parameters, constructor parameter properties, `return` inside `try`/`catch`, object type
+  aliases and inline object types → Go structs, `Record<K, V>` and dictionaries → Go maps
+- **Typing**: contextual types for object/array/function literals, narrowing of `T | undefined`,
+  JS truthiness, `??` chains, nullable ternaries, optional chains across calls
+- **Library**: `toFixed`, `Math.max(...arr)`, `sort` with comparators, `flat`, typed
+  `Object.keys`/`values`, regex `replace` (`/g`, `$1`/`$&`, function replacers), `match`/`split`
+  with regexes, `Array.isArray`, `console.warn`, `fs.unlinkSync`, `process.env['X']`
+- Tests 33–50
+
+### Changed
+
+- **Go 1.23 or newer is required** (generated code uses `slices`/`maps` iterator helpers)
+- `process.platform` reports Node's names (`win32`, `darwin`, `linux`)
+- `JSON.stringify` no longer escapes `<`, `>`, `&` (like JS)
+- Out-of-range array/string reads give zero values instead of panicking (JS `undefined`)
+- Imports and helpers are emitted in sorted order
+- Map, Set and Record keep insertion order (like JS); objects are references (Go pointers)
+
+### Fixed
+
+- The test suite never ran (scripts called `bin/index.js`, which has no entry point); it now runs
+  through `bin/cli.js`
+- Phase 3c regressions (19 tests): AST kind names, missing parent links, `extends` detection
+- Main-file top-level variables were invisible to functions
+- `spawnSync` with `stdio: 'inherit'` dropped its arguments
+
 ## [0.0.21] - 2026-09-06
 
 Self-hosting milestone: the compiler no longer depends on `execa`, `fs-extra`, or `nanoid`, and the

package/CONTRIBUTION.md

@@ -0,0 +1,130 @@
+# Contributing to TypeNative
+
+Thanks for helping build TypeNative — a TypeScript-to-Go transpiler that ships native binaries. Contributions of all sizes are welcome: new language features, standard-library coverage, bug fixes, docs, and probes.
+
+> New here? Read [README.md](README.md) first — it explains what TypeNative is, how the pipeline works, and the repo layout.
+
+## Ways to contribute
+
+- **Add a missing feature** — pick a ❌ row in [conformance.md](conformance.md) and make it ✅.
+- **Fix a bug** — failing probe, wrong Go output, bad error message.
+- **Improve docs** — README, conformance matrix, code comments.
+- **Report issues** — open an issue with a minimal `.ts` repro, expected vs. actual output, and your `node --version` / `go version`.
+
+## Prerequisites
+
+- [Node.js v24](https://nodejs.org/en) or newer.
+- [Go 1.26](https://go.dev/doc/install) or newer — hard minimum (`tsparser/go.mod` declares `go 1.26.0`).
+
+## Setup
+
+```sh
+git clone https://github.com/danisss9/typenative.git
+cd typenative
+npm ci
+npm run build        # tsc -> bin/
+npm run conformance  # full probe suite, must be green before you start
+```
+
+## How a feature gets added
+
+Every supported feature follows the same four-step loop. Do all four — a transpiler change without a probe (or vice versa) will not be merged.
+
+### 1. Write a probe in `conformance/`
+
+One file per feature, named by area:
+
+| Prefix | Meaning | Example |
+| ------ | ------- | ------- |
+| `syntax-` | Language syntax | `syntax-optional-chaining.ts` |
+| `semantics-` | Runtime behavior | `semantics-loose-equality.ts` |
+| `lib-` | Standard-library API | `lib-map.ts` |
+
+Probe conventions:
+
+- Self-contained — no imports except the module under test, no external files.
+- Exercise the feature with `console.log` **and** verify with `assert(condition, 'message')`.
+- A passing probe transpiles, compiles with `go build`, runs, and exits `0`. Anything else is a failure.
+
+```ts
+// conformance/lib-map.ts
+const m = new Map<string, number>([['a', 1]]);
+m.set('b', 2);
+assert(m.size === 2 && m.get('a') === 1 && m.has('b') && !m.has('c'), 'map');
+```
+
+Run just your probe while iterating:
+
+```sh
+node scripts/conformance.mjs lib-map        # substring filter
+node scripts/conformance.mjs --native lib-map  # same, via self-hosted binary
+```
+
+### 2. Extend the ambient types in `types/`
+
+The `.d.ts` files are the type-checking contract for user code. If your feature adds API surface, declare it:
+
+- `types/typenative.d.ts` — core JS subset (`Array`, `Map`, `Set`, `JSON`, `Math`, `RegExp`, …).
+- `types/typenative-npm.d.ts` — `node:*` shims (`fs`, `path`, `os`, `child_process`, …).
+- `types/typenative-go.d.ts` — `go:*` bridges (`fmt`, `strings`, `strconv`).
+
+No signature → user code won't type-check → the feature doesn't exist.
+
+### 3. Implement in `src/transpiler.ts`
+
+- Match on `node.kind === 'Xxx'` strings (never the `typescript` enum) so the same code consumes Node- and Go-produced ASTs.
+- Emit a warning, not a crash, for anything still unsupported: `console.warn('[TypeNative] Unsupported syntax: …')`.
+- Keep the transpiler free of Node-only dependencies (see below).
+
+### 4. Document in `conformance.md`
+
+Add or flip the matrix row and link your probe. Keep ✅/❌ honest — known gaps stay visible, and the [roadmap](conformance.md#roadmap-known-limitations) lists structural limitations.
+
+## The transpilability rule
+
+This is the one rule that breaks the build if ignored: **`src/index.ts`, `src/transpiler.ts`, `src/main.ts`, `src/prompt.ts`, and `src/parse-native.ts` must transpile with TypeNative itself.** That means:
+
+- ❌ No `inquirer`, no async Node-only APIs, no unmapped modules in those files.
+- ✅ Node-only code lives in `src/cli.ts` (prompts) and `src/parse-node.ts` (`typescript` package) and is injected at the boundary — e.g. `run({ ..., parse: parseAstJson })`.
+- ✅ Prompts in transpilable code go through `src/prompt.ts` (`node:readline` → Go helper).
+
+If you need a new capability in transpilable code, add the mapping (transpiler + `types/` shim) first, then use it.
+
+## Code style
+
+- Prettier config is in [.prettierrc.json](.prettierrc.json): 100-char width, 2-space indent, single quotes, semicolons, no trailing commas.
+- Match surrounding code. Small, focused diffs beat refactors — don't reformat unrelated files.
+- Comment *why*, not *what*. The codebase already documents module roles in file headers (`src/parse-node.ts`, `tsparser/main.go`, …) — update the header if you change a module's role.
+
+## Testing
+
+```sh
+npm run build                  # must pass: tsc with strict mode
+npm run conformance            # full suite via Node CLI — must be 100% green
+node scripts/conformance.mjs <filter>          # iterate on one area
+node scripts/conformance.mjs --native <filter> # parity via self-hosted binary
+```
+
+If you touched anything transpilable, also verify self-hosting:
+
+```sh
+npm run build:native            # builds native/tsparser + native/typenative
+node scripts/conformance.mjs --native  # full suite through your new binary
+```
+
+CI ([`.github/workflows/ci.yml`](.github/workflows/ci.yml)) runs `npm ci` → `npm run build` → `npm run conformance` on Ubuntu (Node 24 + Go). Match it locally before pushing.
+
+## Pull requests
+
+1. Fork, branch from `main` (`feat/<probe-name>`, `fix/<what>`, `docs/<what>`).
+2. One feature per PR. Include: probe + types + transpiler + `conformance.md` row.
+3. Describe: what TypeScript now transpiles, sample input/output Go if non-obvious, and conformance results (`total x/y`, plus `--native` if applicable).
+4. Keep CI green — a red suite is the fastest way to get a review delayed.
+
+## Releases
+
+Releases are cut from `TypeNative_*` tags via trusted publishing ([release workflow](.github/workflows/npm-publish-github-packages.yml)). Don't bump `package.json` versions in PRs — the tag drives the version.
+
+## License
+
+By contributing, you agree your changes are MIT-licensed like the rest of the project. See [LICENSE](LICENSE).