typenative 0.0.17 → 0.0.18

package/bin/transpiler.js

@@ -36,14 +36,14 @@ export function transpileToNative(code) {
     enumBaseTypes.clear();
     const transpiledCode = visit(sourceFile, { addFunctionOutside: true });
     const transpiledCodeOutside = outsideNodes.map((n) => visit(n, { isOutside: true })).join('\n');
-    return `package main
-
-${[...importedPackages].map((pkg) => `import "${pkg}"`).join('\n')}
-
-func main() {
-    ${transpiledCode.trim()}
-}
- 
+    return `package main
+
+${[...importedPackages].map((pkg) => `import "${pkg}"`).join('\n')}
+
+func main() {
+    ${transpiledCode.trim()}
+}
+ 
 ${transpiledCodeOutside.trim()}`;
 }
 export function visit(node, options = {}) {
@@ -237,9 +237,23 @@ export function visit(node, options = {}) {
         })}; ${visit(node.incrementor, { inline: true })}${visit(node.statement)}`;
     }
     else if (ts.isForOfStatement(node)) {
-        return `for _,${visit(node.initializer, { inline: true })}= range ${visit(node.expression, {
-            inline: true
-        })}${visit(node.statement)}`;
+        const iterExpr = visit(node.expression, { inline: true });
+        const iterType = inferExpressionType(node.expression);
+        if (iterType && iterType.startsWith('map[')) {
+            const valueType = extractMapValueType(iterType);
+            const isSet = valueType === 'struct{}';
+            const varInfo = getForOfVarNames(node.initializer);
+            if (isSet) {
+                return `for ${varInfo[0]} := range ${iterExpr}${visit(node.statement)}`;
+            }
+            else if (varInfo.length >= 2) {
+                return `for ${varInfo[0]}, ${varInfo[1]} := range ${iterExpr}${visit(node.statement)}`;
+            }
+            else {
+                return `for ${varInfo[0]} := range ${iterExpr}${visit(node.statement)}`;
+            }
+        }
+        return `for _,${visit(node.initializer, { inline: true })}= range ${iterExpr}${visit(node.statement)}`;
     }
     else if (ts.isWhileStatement(node)) {
         return `for ${visit(node.expression, { inline: true })}${visit(node.statement)}`;
@@ -281,6 +295,20 @@ export function visit(node, options = {}) {
     else if (ts.isBreakStatement(node)) {
         return 'break';
     }
+    else if (ts.isThrowStatement(node)) {
+        const expr = node.expression;
+        if (ts.isNewExpression(expr) &&
+            ts.isIdentifier(expr.expression) &&
+            expr.expression.text === 'Error') {
+            const args = expr.arguments ?? [];
+            const msg = args.length > 0 ? visit(args[0]) : '""';
+            return `panic(${msg})` + (options.inline ? '' : ';\n\t');
+        }
+        return `panic(${visit(expr)})` + (options.inline ? '' : ';\n\t');
+    }
+    else if (ts.isTryStatement(node)) {
+        return visitTryStatement(node, options);
+    }
     else if (ts.isReturnStatement(node)) {
         // Handle return new Promise(...)
         if (node.expression &&
@@ -296,26 +324,41 @@ export function visit(node, options = {}) {
             outsideNodes.push(node);
             return '';
         }
-        const name = visit(node.name, { inline: true });
-        const safeName = getSafeName(name);
         const typeParams = getTypeParameters(node.typeParameters);
         const parameterInfo = getFunctionParametersInfo(node.parameters);
-        const returnType = node.type ? ` ${getType(node.type)}` : '';
+        if (node.body && ts.isBlock(node.body)) {
+            prescanVariableDeclarations(node.body);
+        }
+        const inferredRetType = inferFunctionBodyReturnType(node);
+        const returnType = inferredRetType ? ` ${inferredRetType}` : '';
         if (options.isOutside) {
+            const name = node.name ? visit(node.name, { inline: true }) : '';
+            const safeName = getSafeName(name);
             return `func ${safeName}${typeParams}(${parameterInfo.signature})${returnType} ${visit(node.body, {
                 prefixBlockContent: parameterInfo.prefixBlockContent
             })}`;
         }
+        if (!node.name) {
+            return `func${typeParams}(${parameterInfo.signature})${returnType} ${visit(node.body, {
+                prefixBlockContent: parameterInfo.prefixBlockContent
+            })}`;
+        }
+        const name = visit(node.name, { inline: true });
+        const safeName = getSafeName(name);
         return `${safeName} := func${typeParams}(${parameterInfo.signature})${returnType} ${visit(node.body, {
             prefixBlockContent: parameterInfo.prefixBlockContent
         })}`;
     }
     else if (ts.isArrowFunction(node)) {
         const parameterInfo = getFunctionParametersInfo(node.parameters);
-        const returnType = node.type ? ` ${getType(node.type)}` : '';
+        const inferredRetType = inferFunctionBodyReturnType(node);
+        const returnType = inferredRetType ? ` ${inferredRetType}` : '';
         if (parameterInfo.prefixBlockContent && !ts.isBlock(node.body)) {
             return `func(${parameterInfo.signature})${returnType} {\n\t\t${parameterInfo.prefixBlockContent}return ${visit(node.body)};\n\t}`;
         }
+        if (!ts.isBlock(node.body)) {
+            return `func(${parameterInfo.signature})${returnType} { return ${visit(node.body)}; }`;
+        }
         return `func(${parameterInfo.signature})${returnType} ${visit(node.body, {
             prefixBlockContent: parameterInfo.prefixBlockContent
         })}`;
@@ -480,6 +523,12 @@ export function visit(node, options = {}) {
             }
             return `regexp.MustCompile("")`;
         }
+        if (className === 'Map') {
+            return visitNewMap(node);
+        }
+        if (className === 'Set') {
+            return visitNewSet(node);
+        }
         const typeArgs = getTypeArguments(node.typeArguments);
         const args = node.arguments ? node.arguments.map((a) => visit(a)) : [];
         return `New${className}${typeArgs}(${args.join(', ')})`;
@@ -571,7 +620,52 @@ function inferExpectedTypeFromContext(node) {
     }
     return undefined;
 }
+function prescanVariableDeclarations(block) {
+    for (const stmt of block.statements) {
+        if (ts.isVariableStatement(stmt)) {
+            for (const decl of stmt.declarationList.declarations) {
+                if (ts.isIdentifier(decl.name) && !variableGoTypes.has(decl.name.text)) {
+                    if (decl.type) {
+                        variableGoTypes.set(decl.name.text, getType(decl.type));
+                    }
+                    else if (decl.initializer) {
+                        const inferredType = inferExpressionType(decl.initializer);
+                        if (inferredType)
+                            variableGoTypes.set(decl.name.text, inferredType);
+                    }
+                }
+            }
+        }
+    }
+}
+function inferFunctionBodyReturnType(node) {
+    if (node.type)
+        return getType(node.type);
+    if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
+        return inferExpressionType(node.body);
+    }
+    if (node.body && ts.isBlock(node.body)) {
+        for (const stmt of node.body.statements) {
+            if (ts.isReturnStatement(stmt) && stmt.expression) {
+                const exprType = inferExpressionType(stmt.expression);
+                if (exprType)
+                    return exprType;
+            }
+        }
+    }
+    return undefined;
+}
+function inferArrowFunctionGoType(node) {
+    const params = node.parameters
+        .map((p) => (p.type ? getType(p.type) : 'interface{}'))
+        .join(', ');
+    const retType = inferFunctionBodyReturnType(node);
+    return `func(${params})${retType ? ` ${retType}` : ''}`;
+}
 function inferExpressionType(expr) {
+    if (ts.isArrowFunction(expr) || ts.isFunctionExpression(expr)) {
+        return inferArrowFunctionGoType(expr);
+    }
     if (ts.isParenthesizedExpression(expr))
         return inferExpressionType(expr.expression);
     if (ts.isNonNullExpression(expr))
@@ -599,6 +693,15 @@ function inferExpressionType(expr) {
         const firstElementType = inferExpressionType(expr.elements[0]) ?? 'interface{}';
         return `[]${firstElementType}`;
     }
+    if (ts.isNewExpression(expr) && ts.isIdentifier(expr.expression)) {
+        const ctorName = expr.expression.text;
+        if (ctorName === 'Map' && expr.typeArguments && expr.typeArguments.length === 2) {
+            return `map[${getType(expr.typeArguments[0])}]${getType(expr.typeArguments[1])}`;
+        }
+        if (ctorName === 'Set' && expr.typeArguments && expr.typeArguments.length === 1) {
+            return `map[${getType(expr.typeArguments[0])}]struct{}`;
+        }
+    }
     if (ts.isPropertyAccessExpression(expr)) {
         if (ts.isIdentifier(expr.expression) && enumNames.has(expr.expression.text)) {
             const enumType = getSafeName(expr.expression.text);
@@ -634,6 +737,12 @@ function inferExpressionType(expr) {
     if (ts.isCallExpression(expr) && ts.isPropertyAccessExpression(expr.expression)) {
         const methodName = expr.expression.name.text;
         const ownerType = inferExpressionType(expr.expression.expression);
+        if (ownerType && ownerType.startsWith('map[')) {
+            if (methodName === 'has')
+                return 'bool';
+            if (methodName === 'get')
+                return extractMapValueType(ownerType);
+        }
         if (isArrayLikeGoType(ownerType)) {
             const elementType = getArrayElementTypeFromGoType(ownerType);
             if (methodName === 'map') {
@@ -1026,6 +1135,13 @@ function getType(typeNode, getArrayType = false) {
         // Non-nullable union or multi-type union → interface{}
         return 'interface{}';
     }
+    if (ts.isFunctionTypeNode(typeNode)) {
+        const params = typeNode.parameters
+            .map((p) => (p.type ? getType(p.type) : 'interface{}'))
+            .join(', ');
+        const ret = typeNode.type ? ` ${getType(typeNode.type)}` : '';
+        return `func(${params})${ret}`;
+    }
     if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
         const name = typeNode.typeName.text;
         if (enumNames.has(name)) {
@@ -1041,6 +1157,15 @@ function getType(typeNode, getArrayType = false) {
         if (name === 'RegExp') {
             return '*regexp.Regexp';
         }
+        if (name === 'Map' && typeNode.typeArguments && typeNode.typeArguments.length === 2) {
+            const keyType = getType(typeNode.typeArguments[0]);
+            const valueType = getType(typeNode.typeArguments[1]);
+            return `map[${keyType}]${valueType}`;
+        }
+        if (name === 'Set' && typeNode.typeArguments && typeNode.typeArguments.length === 1) {
+            const elementType = getType(typeNode.typeArguments[0]);
+            return `map[${elementType}]struct{}`;
+        }
         const typeArgs = getTypeArguments(typeNode.typeArguments);
         if (classNames.has(name)) {
             return `*${name}${typeArgs}`;
@@ -1091,6 +1216,10 @@ function getTypeCategory(typeNode) {
     }
     if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
         const name = typeNode.typeName.text;
+        if (name === 'Map')
+            return 'Map';
+        if (name === 'Set')
+            return 'Set';
         if (classNames.has(name))
             return 'class';
         return name;
@@ -1131,6 +1260,9 @@ function getAcessString(leftSide, rightSide, objectType) {
     if (rightSide === 'length' && objectType !== 'class') {
         return `float64(len(${leftSide}))`;
     }
+    if (rightSide === 'size' && (objectType === 'Map' || objectType === 'Set')) {
+        return `float64(len(${leftSide}))`;
+    }
     return `${leftSide}.${rightSide}`;
 }
 const callHandlers = {
@@ -1286,6 +1418,25 @@ const arrayMethodHandlers = {
         return `fmt.Sprintf("%v", ${obj})`;
     }
 };
+const mapMethodHandlers = {
+    set: (obj, args) => `${obj}[${args[0]}] = ${args[1]}`,
+    get: (obj, args) => `${obj}[${args[0]}]`,
+    has: (obj, args) => {
+        const tmp = getTempName('ok');
+        return `func() bool { _, ${tmp} := ${obj}[${args[0]}]; return ${tmp} }()`;
+    },
+    delete: (obj, args) => `delete(${obj}, ${args[0]})`,
+    clear: (obj) => `clear(${obj})`
+};
+const setMethodHandlers = {
+    add: (obj, args) => `${obj}[${args[0]}] = struct{}{}`,
+    has: (obj, args) => {
+        const tmp = getTempName('ok');
+        return `func() bool { _, ${tmp} := ${obj}[${args[0]}]; return ${tmp} }()`;
+    },
+    delete: (obj, args) => `delete(${obj}, ${args[0]})`,
+    clear: (obj) => `clear(${obj})`
+};
 function getDynamicCallHandler(caller, objectType) {
     if (promiseResolveName && caller === promiseResolveName) {
         return (_caller, args) => `ch <- ${args[0]}`;
@@ -1314,6 +1465,12 @@ function getDynamicCallHandler(caller, objectType) {
         else if (objectType === 'RegExp') {
             handler = regexpMethodHandlers[methodName];
         }
+        else if (objectType === 'Map') {
+            handler = mapMethodHandlers[methodName];
+        }
+        else if (objectType === 'Set') {
+            handler = setMethodHandlers[methodName];
+        }
         else {
             // Unknown type: try both maps for backward compatibility
             handler =
@@ -1503,3 +1660,89 @@ function visitNewPromise(node) {
     promiseResolveName = prevResolveName;
     return `func() chan ${channelType} {\n\t\tch := make(chan ${channelType})\n\t\tgo func() ${body.trimEnd()}()\n\t\treturn ch;\n\t}()`;
 }
+function extractMapValueType(mapType) {
+    // mapType is "map[K]V" — find the closing bracket of K accounting for nesting
+    if (!mapType.startsWith('map['))
+        return 'interface{}';
+    let depth = 0;
+    for (let i = 4; i < mapType.length; i++) {
+        if (mapType[i] === '[')
+            depth++;
+        else if (mapType[i] === ']') {
+            if (depth === 0)
+                return mapType.substring(i + 1);
+            depth--;
+        }
+    }
+    return 'interface{}';
+}
+function visitNewMap(node) {
+    let keyType = 'interface{}';
+    let valueType = 'interface{}';
+    if (node.typeArguments && node.typeArguments.length === 2) {
+        keyType = getType(node.typeArguments[0]);
+        valueType = getType(node.typeArguments[1]);
+    }
+    const mapType = `map[${keyType}]${valueType}`;
+    const args = node.arguments;
+    if (!args || args.length === 0 || !ts.isArrayLiteralExpression(args[0])) {
+        return `make(${mapType})`;
+    }
+    const initArg = args[0];
+    const tmp = getTempName('map');
+    const entries = initArg.elements
+        .filter((el) => ts.isArrayLiteralExpression(el) && el.elements.length >= 2)
+        .map((el) => {
+        const pair = el;
+        return `${tmp}[${visit(pair.elements[0])}] = ${visit(pair.elements[1])}`;
+    })
+        .join('; ');
+    return `func() ${mapType} { ${tmp} := make(${mapType}); ${entries}; return ${tmp} }()`;
+}
+function visitNewSet(node) {
+    let elementType = 'interface{}';
+    if (node.typeArguments && node.typeArguments.length === 1) {
+        elementType = getType(node.typeArguments[0]);
+    }
+    const setType = `map[${elementType}]struct{}`;
+    const args = node.arguments;
+    if (!args || args.length === 0 || !ts.isArrayLiteralExpression(args[0])) {
+        return `make(${setType})`;
+    }
+    const initArg = args[0];
+    const tmp = getTempName('set');
+    const values = initArg.elements.map((el) => `${tmp}[${visit(el)}] = struct{}{}`).join('; ');
+    return `func() ${setType} { ${tmp} := make(${setType}); ${values}; return ${tmp} }()`;
+}
+function getForOfVarNames(initializer) {
+    if (!ts.isVariableDeclarationList(initializer) || initializer.declarations.length === 0) {
+        return ['_'];
+    }
+    const decl = initializer.declarations[0];
+    if (ts.isArrayBindingPattern(decl.name)) {
+        return decl.name.elements.map((el) => {
+            if (ts.isOmittedExpression(el))
+                return '_';
+            return visit(el.name);
+        });
+    }
+    return [visit(decl.name)];
+}
+function visitTryStatement(node, options) {
+    const deferreds = [];
+    // Register finally first (LIFO: runs last after catch)
+    if (node.finallyBlock) {
+        const finallyBody = node.finallyBlock.statements.map((s) => visit(s)).join('\t');
+        deferreds.push(`defer func() {\n\t\t\t${finallyBody}\t\t\t}()`);
+    }
+    // Register catch second (LIFO: runs first, handles panic via recover)
+    if (node.catchClause) {
+        const varDecl = node.catchClause.variableDeclaration;
+        const catchVar = varDecl ? visit(varDecl.name) : '_r';
+        const catchBody = node.catchClause.block.statements.map((s) => visit(s)).join('\t');
+        deferreds.push(`defer func() {\n\t\t\tif r := recover(); r != nil {\n\t\t\t\t${catchVar} := r\n\t\t\t\t_ = ${catchVar}\n\t\t\t\t${catchBody}\t\t\t}\n\t\t\t}()`);
+    }
+    const tryBody = node.tryBlock.statements.map((s) => visit(s)).join('\t');
+    const body = [...deferreds, tryBody].join('\n\t\t\t');
+    return `func() {\n\t\t\t${body}\n\t\t\t}()` + (options.inline ? '' : ';\n\t');
+}

package/package.json

@@ -1,59 +1,63 @@
-{
-  "name": "typenative",
-  "version": "0.0.17",
-  "description": "Build native applications using Typescript.",
-  "type": "module",
-  "bin": {
-    "typenative": "bin/index.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "watch": "tsc --watch",
-    "test": "node ./test/test-runner test",
-    "release": "npm publish",
-    "test1": "node ./bin/index --source test/test1.spec.ts --script",
-    "test2": "node ./bin/index --source test/test2.spec.ts --script",
-    "test3": "node ./bin/index --source test/test3.spec.ts --script",
-    "test3_node": "tsc test/test3.spec.ts && node test/test3.spec.js && rimraf test/test3.spec.js",
-    "test4": "node ./bin/index --source test/test4.spec.ts --script",
-    "test5": "node ./bin/index --source test/test5.spec.ts --script",
-    "test6": "node ./bin/index --source test/test6.spec.ts --script",
-    "test7": "node ./bin/index --source test/test7.spec.ts --script",
-    "test8": "node ./bin/index --source test/test8.spec.ts --script",
-    "test9": "node ./bin/index --source test/test9.spec.ts --script",
-    "test10": "node ./bin/index --source test/test10.spec.ts --script",
-    "test11": "node ./bin/index --source test/test11.spec.ts --script",
-    "test12": "node ./bin/index --source test/test12.spec.ts --script",
-    "test13": "node ./bin/index --source test/test13.spec.ts --script",
-    "test14": "node ./bin/index --source test/test14.spec.ts --script",
-    "test15": "node ./bin/index --source test/test15.spec.ts --script",
-    "test16": "node ./bin/index --source test/test16.spec.ts --script",
-    "test17": "node ./bin/index --source test/test17.spec.ts --script",
-    "test18": "node ./bin/index --source test/test18.spec.ts --script",
-    "test19": "node ./bin/index --source test/test19.spec.ts --script",
-    "test20": "node ./bin/index --source test/Test20.spec.ts --script"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/danisss9/typenative.git"
-  },
-  "author": "Dani Santos",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/danisss9/typenative/issues"
-  },
-  "homepage": "https://github.com/danisss9/typenative#readme",
-  "devDependencies": {
-    "@types/fs-extra": "^11.0.4",
-    "@types/inquirer": "^9.0.9",
-    "@types/node": "^25.2.3",
-    "rimraf": "^6.1.2"
-  },
-  "dependencies": {
-    "execa": "^9.6.1",
-    "fs-extra": "^11.3.3",
-    "inquirer": "^13.2.4",
-    "nanoid": "^5.1.6",
-    "typescript": "^5.9.3"
-  }
-}
+{
+  "name": "typenative",
+  "version": "0.0.18",
+  "description": "Build native applications using Typescript.",
+  "type": "module",
+  "bin": {
+    "typenative": "bin/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "test": "node ./test/test-runner test",
+    "release": "npm publish",
+    "test1": "node ./bin/index --source test/test1.spec.ts --script",
+    "test2": "node ./bin/index --source test/test2.spec.ts --script",
+    "test3": "node ./bin/index --source test/test3.spec.ts --script",
+    "test3_node": "tsc test/test3.spec.ts && node test/test3.spec.js && rimraf test/test3.spec.js",
+    "test4": "node ./bin/index --source test/test4.spec.ts --script",
+    "test5": "node ./bin/index --source test/test5.spec.ts --script",
+    "test6": "node ./bin/index --source test/test6.spec.ts --script",
+    "test7": "node ./bin/index --source test/test7.spec.ts --script",
+    "test8": "node ./bin/index --source test/test8.spec.ts --script",
+    "test9": "node ./bin/index --source test/test9.spec.ts --script",
+    "test10": "node ./bin/index --source test/test10.spec.ts --script",
+    "test11": "node ./bin/index --source test/test11.spec.ts --script",
+    "test12": "node ./bin/index --source test/test12.spec.ts --script",
+    "test13": "node ./bin/index --source test/test13.spec.ts --script",
+    "test14": "node ./bin/index --source test/test14.spec.ts --script",
+    "test15": "node ./bin/index --source test/test15.spec.ts --script",
+    "test16": "node ./bin/index --source test/test16.spec.ts --script",
+    "test17": "node ./bin/index --source test/test17.spec.ts --script",
+    "test18": "node ./bin/index --source test/test18.spec.ts --script",
+    "test19": "node ./bin/index --source test/test19.spec.ts --script",
+    "test20": "node ./bin/index --source test/Test20.spec.ts --script",
+    "test21": "node ./bin/index --source test/Test21.spec.ts --script",
+    "test22": "node ./bin/index --source test/Test22.spec.ts --script",
+    "test23": "node ./bin/index --source test/Test23.spec.ts --script",
+    "test24": "node ./bin/index --source test/Test24.spec.ts --script"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/danisss9/typenative.git"
+  },
+  "author": "Dani Santos",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/danisss9/typenative/issues"
+  },
+  "homepage": "https://github.com/danisss9/typenative#readme",
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^25.2.3",
+    "rimraf": "^6.1.2"
+  },
+  "dependencies": {
+    "execa": "^9.6.1",
+    "fs-extra": "^11.3.3",
+    "inquirer": "^13.2.4",
+    "nanoid": "^5.1.6",
+    "typescript": "^5.9.3"
+  }
+}