typenative 0.0.10 → 0.0.11

package/README.md

@@ -33,18 +33,24 @@ TypeNative currently supports a subset of TypeScript syntax elements that are tr
 | Increment/Decrement | ✅ | `++`, `--` |
 | **Control Flow** |  |  |
 | For loops | ✅ | Standard `for` loops |
+| For...of loops | ✅ | Iteration over arrays |
+| While loops | ✅ | Transpiled to Go's `for` loops |
+| Do...while loops | ✅ | Implemented with conditional break |
+| If/Else statements | ✅ | Fully supported |
+| Switch statements | ✅ | Case and default statements |
 | **Data Structures** |  |  |
 | Arrays | ✅ | Basic array operations |
+| Array methods | ✅ | `push` supported |
 | **Functions** |  |  |
 | console.log | ✅ | Mapped to `fmt.Println` |
+| console.time/timeEnd | ✅ | Performance measurement |
+| Math.random | ✅ | Mapped to Go's `rand.Float64()` |
+| Math.floor | ✅ | Mapped to Go's `math.Floor()` |
 | **Unsupported Features** |  |  |
 | Classes | ❌ | Not implemented |
 | Interfaces | ❌ | Not implemented |
 | Functions | ❌ | Custom function definitions not supported |
 | Arrow Functions | ❌ | Not implemented |
-| If/Else statements | ❌ | Not implemented |
-| While/Do loops | ❌ | Not implemented |
-| Switch statements | ❌ | Not implemented |
 | Async/Await | ❌ | Not implemented |
 | Modules/Imports | ❌ | Not implemented |
 | Generics | ❌ | Not implemented |

package/bin/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import inquirer from 'inquirer';
-import shell from 'shelljs';
 import fs from 'fs-extra';
 import path from 'path';
+import { execa } from 'execa';
 import { transpileToNative } from './transpiler.js';
 import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
@@ -37,14 +37,16 @@ const __dirname = path.dirname(__filename);
     const nativeCode = transpileToNative(tsCode);
     await fs.ensureDir('dist');
     await fs.writeFile('dist/code.go', nativeCode, { encoding: 'utf-8' });
-    shell.exec('go build -o dist/native.exe dist/code.go');
+    await execa('go build -o dist/native.exe dist/code.go');
     // await fs.remove('dist/code.go');
     if (answers.output) {
         await fs.copy('dist/native.exe', answers.output, { overwrite: true });
         await fs.remove('dist/native.exe');
     }
     if (scriptMode) {
-        shell.exec(path.join('dist', 'native.exe'));
+        await execa('dist/native.exe', {
+            stdio: 'inherit'
+        });
         await fs.remove('dist/native.exe');
     }
     else {

package/bin/transpiler.js

@@ -1,17 +1,20 @@
 import ts from 'typescript';
 let TypeCheker;
+let importedPackages = new Set();
 export function transpileToNative(code) {
     const sourceFile = ts.createSourceFile('main.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
     TypeCheker = ts.createProgram(['main.ts'], {}).getTypeChecker();
+    importedPackages.clear();
+    const transpiledCode = visit(sourceFile);
     return `package main
 
-import "fmt"
+${[...importedPackages].map((pkg) => `import "${pkg}"`).join('\n')}
 
 func main() {
-    ${visit(sourceFile)}
+    ${transpiledCode.trim()}
 }`;
 }
-export function visit(node, inline = false) {
+export function visit(node, inline = false, extraBlockContent = '') {
     let code = '';
     if (ts.isIdentifier(node)) {
         return node.text;
@@ -28,20 +31,30 @@ export function visit(node, inline = false) {
     else if (ts.isToken(node) && node.kind === ts.SyntaxKind.FalseKeyword) {
         return `false`;
     }
+    else if (ts.isArrayLiteralExpression(node)) {
+        const type = ts.isVariableDeclaration(node.parent) ? getType(node.parent.type, true) : '';
+        return `[]${type} {${node.elements.map((e) => visit(e)).join(', ')}}`;
+    }
     else if (ts.isBlock(node)) {
-        return `{\n\t\t${node.statements.map((n) => visit(n)).join('\t')}}\n\t`;
+        return `{\n\t\t${node.statements.map((n) => visit(n)).join('\t')}${extraBlockContent}}${inline ? '' : '\n\t'}`;
+    }
+    else if (ts.isElementAccessExpression(node)) {
+        return `${visit(node.expression)}[int(${visit(node.argumentExpression)})]`;
     }
     else if (ts.isPropertyAccessExpression(node)) {
-        return `${visit(node.expression)}.${visit(node.name)}`;
+        const leftSide = visit(node.expression);
+        const rightSide = visit(node.name);
+        return getAcessString(leftSide, rightSide);
     }
     else if (ts.isVariableDeclaration(node)) {
         const type = getType(node.type);
         const initializer = node.initializer ? `= ${visit(node.initializer)}` : '';
-        return `${type === ':' ? '' : 'var'} ${visit(node.name)} ${type}${type === ':' ? '' : ' '}${initializer}`;
+        return `${type === ':' ? '' : 'var '}${visit(node.name)} ${type}${type === ':' ? '' : ' '}${initializer}`;
     }
     else if (ts.isCallExpression(node)) {
-        const expr = visit(node.expression);
-        return `${getFunction(expr)}(${node.arguments.map((a) => visit(a)).join(',')})`;
+        const caller = visit(node.expression);
+        const args = node.arguments.map((a) => visit(a));
+        return getCallString(caller, args);
     }
     else if (ts.isPrefixUnaryExpression(node)) {
         return `${getOperatorText(node.operator)}${visit(node.operand)}`;
@@ -56,24 +69,53 @@ export function visit(node, inline = false) {
         return `(${visit(node.expression)})`;
     }
     else if (ts.isVariableDeclarationList(node)) {
-        return (node.declarations.map((n) => visit(n)).join(inline ? ';' : ';\n\t') + (inline ? ';' : ';\n\t'));
+        return (node.declarations.map((n) => visit(n)).join(inline ? ';' : ';\n\t') + (inline ? '' : ';\n\t'));
     }
     else if (ts.isExpressionStatement(node)) {
-        return visit(node.expression) + (inline ? ';' : ';\n\t');
+        return visit(node.expression) + (inline ? '' : ';\n\t');
     }
     else if (ts.isForStatement(node)) {
-        return `for${visit(node.initializer, true)} ${visit(node.condition, true)}; ${visit(node.incrementor, true)}${visit(node.statement)}`;
+        return `for ${visit(node.initializer, true)}; ${visit(node.condition, true)}; ${visit(node.incrementor, true)}${visit(node.statement)}`;
+    }
+    else if (ts.isForOfStatement(node)) {
+        return `for _,${visit(node.initializer, true)}= range ${visit(node.expression, true)}${visit(node.statement)}`;
+    }
+    else if (ts.isWhileStatement(node)) {
+        return `for ${visit(node.expression, true)}${visit(node.statement)}`;
+    }
+    else if (ts.isDoStatement(node)) {
+        const condition = `\tif !(${visit(node.expression, true)}) {\n\t\t\tbreak \n\t\t}\n\t`;
+        return `for ${visit(node.statement, false, condition)}`;
+    }
+    else if (ts.isIfStatement(node)) {
+        const condition = `if ${visit(node.expression, true)} ${visit(node.thenStatement, true)}`;
+        if (node.elseStatement) {
+            return `${condition} else ${visit(node.elseStatement)}`;
+        }
+        return condition;
+    }
+    const syntaxKind = ts.SyntaxKind[node.kind];
+    if (!['SourceFile', 'FirstStatement', 'EndOfFileToken'].includes(syntaxKind)) {
+        console.log(ts.SyntaxKind[node.kind], node.getText());
     }
-    console.log(ts.SyntaxKind[node.kind], node.getText());
     ts.forEachChild(node, (subNode) => {
         code += visit(subNode);
         return null;
     });
     return code;
 }
-function getType(typeNode) {
+function getType(typeNode, getArrayType = false) {
     const type = TypeCheker.getTypeFromTypeNode(typeNode);
-    const typeName = TypeCheker.typeToString(type);
+    let typeName = TypeCheker.typeToString(type);
+    const isArray = typeNode?.kind & ts.SyntaxKind.ArrayType;
+    if (isArray) {
+        if (getArrayType) {
+            typeName = typeName.replace('[]', '');
+        }
+        else {
+            return ':';
+        }
+    }
     switch (typeName) {
         case 'number':
             return 'float64';
@@ -85,13 +127,39 @@ function getType(typeNode) {
             return typeName;
     }
 }
-function getFunction(expr) {
-    switch (expr) {
-        case 'console.log':
-            return 'fmt.Println';
-        default:
-            return expr;
+function getAcessString(leftSide, rightSide) {
+    if (rightSide === 'length') {
+        return 'float64(len(arr))';
     }
+    return `${leftSide}.${rightSide}`;
+}
+function getCallString(caller, args) {
+    if (caller === 'console.log') {
+        importedPackages.add('fmt');
+        return `fmt.Println(${args.join(', ')})`;
+    }
+    else if (caller === 'console.time') {
+        importedPackages.add('time');
+        return `${getTimerName(args[0])} := time.Now()`;
+    }
+    else if (caller === 'console.timeEnd') {
+        importedPackages.add('time');
+        importedPackages.add('fmt');
+        return `fmt.Println("Elapsed time:", time.Since(${getTimerName(args[0])}))`;
+    }
+    else if (caller === 'Math.random') {
+        importedPackages.add('math/rand');
+        return 'rand.Float64()';
+    }
+    else if (caller === 'Math.floor') {
+        importedPackages.add('math');
+        return `math.Floor(${args.join(', ')})`;
+    }
+    else if (caller.endsWith('.push')) {
+        const arrayName = caller.substring(0, caller.length - '.push'.length);
+        return `${arrayName} = append(${arrayName},${args.join(', ')})`;
+    }
+    return `${caller}(${args.join(', ')})`;
 }
 function getOperatorText(operator) {
     switch (operator) {
@@ -107,5 +175,11 @@ function getOperatorText(operator) {
             return '++';
         case ts.SyntaxKind.MinusMinusToken:
             return '--';
+        default:
+            console.error('Did not find operator', operator);
+            return '';
     }
 }
+function getTimerName(name) {
+    return `__timer_${name.replaceAll(' ', '_').replaceAll('"', '')}__`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typenative",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "Build native applications using Typescript.",
   "type": "module",
   "bin": {
@@ -14,7 +14,10 @@
     "test": "node ./bin/index --source test/test.ts --script",
     "test2": "node ./bin/index --source test/test2.ts --script",
     "test3": "node ./bin/index --source test/test3.ts --script",
+    "test3_node": "tsc test/test3.ts && node test/test3.js && rimraf test/test3.js",
     "test4": "node ./bin/index --source test/test4.ts --script",
+    "test5": "node ./bin/index --source test/test5.ts --script",
+    "test6": "node ./bin/index --source test/test6.ts --script",
     "release": "npm publish"
   },
   "repository": {
@@ -31,12 +34,12 @@
     "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "^9.0.8",
     "@types/node": "^22.15.21",
-    "@types/shelljs": "^0.8.16"
+    "rimraf": "^6.0.1"
   },
   "dependencies": {
+    "execa": "^9.5.3",
     "fs-extra": "^11.3.0",
     "inquirer": "^12.6.1",
-    "shelljs": "^0.10.0",
     "typescript": "^5.8.3"
   }
 }

package/types/typenative.d.ts

@@ -1,4 +1,33 @@
-interface Array<T> {
+interface SymbolConstructor {
+  readonly iterator: unique symbol;
+}
+
+declare var Symbol: SymbolConstructor;
+
+interface IteratorYieldResult<TYield> {
+  done?: false;
+  value: TYield;
+}
+
+interface IteratorReturnResult<TReturn> {
+  done: true;
+  value: TReturn;
+}
+
+type IteratorResult<T, TReturn = any> = IteratorYieldResult<T> | IteratorReturnResult<TReturn>;
+
+interface Iterator<T, TReturn = any, TNext = any> {
+  // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
+  next(...[value]: [] | [TNext]): IteratorResult<T, TReturn>;
+  return?(value?: TReturn): IteratorResult<T, TReturn>;
+  throw?(e?: any): IteratorResult<T, TReturn>;
+}
+
+interface IterableIterator<T, TReturn = any, TNext = any> extends Iterator<T, TReturn, TNext> {
+  [Symbol.iterator](): IterableIterator<T, TReturn, TNext>;
+}
+
+interface Array<T> extends IterableIterator<T> {
   /**
    * Gets or sets the length of the array. This is a number one higher than the highest index in the array.
    */
@@ -13,5 +42,13 @@ interface Array<T> {
 
 interface Console {
   log(...data: any[]): void;
+  time(label?: string): void;
+  timeEnd(label?: string): void;
 }
 declare var console: Console;
+
+interface Math {
+  random(): number;
+  floor(x: number): number;
+}
+declare var Math: Math;