typenative 0.0.16 → 0.0.18

package/bin/transpiler.js

@@ -9,6 +9,14 @@ let promiseResolveName = '';
 const dangerousNames = new Set(['main']);
 const renamedFunctions = new Map();
 const variableTypes = new Map();
+const variableGoTypes = new Map();
+const variableClassNames = new Map();
+const classPropertyTypes = new Map();
+const classMethodReturnTypes = new Map();
+const interfacePropertyTypes = new Map();
+const typeAliases = new Map();
+const enumNames = new Set();
+const enumBaseTypes = new Map();
 export function transpileToNative(code) {
     const sourceFile = ts.createSourceFile('main.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
     TypeCheker = ts.createProgram(['main.ts'], {}).getTypeChecker();
@@ -18,16 +26,24 @@ export function transpileToNative(code) {
     promiseResolveName = '';
     renamedFunctions.clear();
     variableTypes.clear();
+    variableGoTypes.clear();
+    variableClassNames.clear();
+    classPropertyTypes.clear();
+    classMethodReturnTypes.clear();
+    interfacePropertyTypes.clear();
+    typeAliases.clear();
+    enumNames.clear();
+    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 = {}) {
@@ -43,8 +59,17 @@ export function visit(node, options = {}) {
             return 'nil';
         return getSafeName(node.text);
     }
-    else if (ts.isStringLiteral(node)) {
-        return `"${node.text}"`;
+    else if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+        return toGoStringLiteral(node.text);
+    }
+    else if (ts.isAsExpression(node)) {
+        return visit(node.expression);
+    }
+    else if (ts.isTypeAssertionExpression(node)) {
+        return visit(node.expression);
+    }
+    else if (ts.isTemplateExpression(node)) {
+        return visitTemplateExpression(node);
     }
     else if (ts.isNumericLiteral(node)) {
         return `float64(${node.text})`;
@@ -73,12 +98,23 @@ export function visit(node, options = {}) {
         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')}${options.extraBlockContent ?? ''}}${options.inline ? '' : '\n\t'}`;
+        return `{\n\t\t${options.prefixBlockContent ?? ''}${node.statements
+            .map((n) => visit(n))
+            .join('\t')}${options.extraBlockContent ?? ''}}${options.inline ? '' : '\n\t'}`;
     }
     else if (ts.isElementAccessExpression(node)) {
+        if (hasQuestionDot(node)) {
+            return visitOptionalElementAccess(node);
+        }
         return `${visit(node.expression)}[int(${visit(node.argumentExpression)})]`;
     }
     else if (ts.isPropertyAccessExpression(node)) {
+        if (hasQuestionDot(node)) {
+            return visitOptionalPropertyAccess(node);
+        }
+        if (ts.isIdentifier(node.expression) && enumNames.has(node.expression.text)) {
+            return `${getSafeName(node.expression.text)}_${getEnumMemberName(node.name)}`;
+        }
         const leftSide = visit(node.expression);
         const rightSide = visit(node.name);
         const objectType = resolveExpressionType(node.expression);
@@ -88,9 +124,18 @@ export function visit(node, options = {}) {
         const type = getType(node.type);
         // Track variable type for type-aware method dispatch
         if (ts.isIdentifier(node.name)) {
+            if (node.type) {
+                variableGoTypes.set(node.name.text, getType(node.type));
+            }
             const cat = node.type ? getTypeCategory(node.type) : undefined;
             if (cat) {
                 variableTypes.set(node.name.text, cat);
+                if (cat === 'class' && node.type) {
+                    const className = getClassNameFromTypeNode(node.type);
+                    if (className) {
+                        variableClassNames.set(node.name.text, className);
+                    }
+                }
             }
             else if (node.initializer &&
                 ts.isNewExpression(node.initializer) &&
@@ -100,11 +145,18 @@ export function visit(node, options = {}) {
                 }
                 else if (classNames.has(node.initializer.expression.text)) {
                     variableTypes.set(node.name.text, 'class');
+                    variableClassNames.set(node.name.text, node.initializer.expression.text);
                 }
             }
             else if (node.initializer && ts.isRegularExpressionLiteral(node.initializer)) {
                 variableTypes.set(node.name.text, 'RegExp');
             }
+            if (!variableGoTypes.has(node.name.text) && node.initializer) {
+                const inferredType = inferExpressionType(node.initializer);
+                if (inferredType) {
+                    variableGoTypes.set(node.name.text, inferredType);
+                }
+            }
         }
         let initializer = node.initializer ? `= ${visit(node.initializer)}` : '';
         // Wrap non-nil values assigned to nullable primitive pointer types
@@ -119,6 +171,10 @@ export function visit(node, options = {}) {
         return `${type === ':' ? '' : 'var '}${visit(node.name)} ${type}${type === ':' ? '' : ' '}${initializer}`;
     }
     else if (ts.isCallExpression(node)) {
+        if (hasQuestionDot(node) ||
+            (ts.isPropertyAccessExpression(node.expression) && hasQuestionDot(node.expression))) {
+            return visitOptionalCall(node);
+        }
         // Handle setTimeout specially to get raw delay value
         if (ts.isIdentifier(node.expression) && node.expression.text === 'setTimeout') {
             importedPackages.add('time');
@@ -127,6 +183,10 @@ export function visit(node, options = {}) {
             const delay = ts.isNumericLiteral(delayNode) ? delayNode.text : visit(delayNode);
             return `time.AfterFunc(${delay} * time.Millisecond, ${callback.trimEnd()})`;
         }
+        const arrayHigherOrderCall = visitArrayHigherOrderCall(node);
+        if (arrayHigherOrderCall) {
+            return arrayHigherOrderCall;
+        }
         const caller = visit(node.expression);
         const safeCaller = getSafeName(caller);
         const typeArgs = getTypeArguments(node.typeArguments);
@@ -144,7 +204,13 @@ export function visit(node, options = {}) {
     else if (ts.isPostfixUnaryExpression(node)) {
         return `${visit(node.operand, { inline: true })}${getOperatorText(node.operator)}`;
     }
+    else if (ts.isConditionalExpression(node)) {
+        return visitConditionalExpression(node);
+    }
     else if (ts.isBinaryExpression(node)) {
+        if (node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
+            return visitNullishCoalescingExpression(node);
+        }
         let op = node.operatorToken.getText();
         if (op === '===')
             op = '==';
@@ -171,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)}`;
@@ -215,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 &&
@@ -230,31 +324,74 @@ 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 parameters = node.parameters
-            .map((p) => `${visit(p.name)} ${getType(p.type)}`)
-            .join(', ');
-        const returnType = node.type ? ` ${getType(node.type)}` : '';
+        const parameterInfo = getFunctionParametersInfo(node.parameters);
+        if (node.body && ts.isBlock(node.body)) {
+            prescanVariableDeclarations(node.body);
+        }
+        const inferredRetType = inferFunctionBodyReturnType(node);
+        const returnType = inferredRetType ? ` ${inferredRetType}` : '';
         if (options.isOutside) {
-            return `func ${safeName}${typeParams}(${parameters})${returnType} ${visit(node.body)}`;
+            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
+            })}`;
         }
-        return `${safeName} := func${typeParams}(${parameters})${returnType} ${visit(node.body)}`;
+        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 parameters = node.parameters
-            .map((p) => `${visit(p.name)} ${getType(p.type)}`)
-            .join(', ');
-        const returnType = node.type ? ` ${getType(node.type)}` : '';
-        return `func(${parameters})${returnType} ${visit(node.body)}`;
+        const parameterInfo = getFunctionParametersInfo(node.parameters);
+        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
+        })}`;
     }
     else if (node.kind === ts.SyntaxKind.ThisKeyword) {
         return 'self';
     }
+    else if (ts.isEnumDeclaration(node)) {
+        const enumName = node.name.text;
+        enumNames.add(enumName);
+        enumBaseTypes.set(enumName, getEnumBaseType(node));
+        if (options.addFunctionOutside) {
+            outsideNodes.push(node);
+            return '';
+        }
+        return visitEnumDeclaration(node);
+    }
+    else if (ts.isTypeAliasDeclaration(node)) {
+        typeAliases.set(node.name.text, node.type);
+        return '';
+    }
     else if (ts.isInterfaceDeclaration(node)) {
         if (options.addFunctionOutside) {
             outsideNodes.push(node);
+            const properties = new Map();
+            for (const member of node.members) {
+                if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
+                    properties.set(member.name.text, getOptionalNodeType(member.type, !!member.questionToken));
+                }
+            }
+            if (properties.size > 0) {
+                interfacePropertyTypes.set(visit(node.name), properties);
+            }
             return '';
         }
         const name = visit(node.name);
@@ -270,6 +407,7 @@ export function visit(node, options = {}) {
             }
         }
         const methods = [];
+        const properties = [];
         for (const member of node.members) {
             if (ts.isMethodSignature(member)) {
                 const methodName = visit(member.name);
@@ -279,6 +417,13 @@ export function visit(node, options = {}) {
                 const returnType = member.type ? ` ${getType(member.type)}` : '';
                 methods.push(`\t${methodName}(${params})${returnType}`);
             }
+            else if (ts.isPropertySignature(member) && ts.isIdentifier(member.name)) {
+                properties.push(`\t${member.name.text} ${getOptionalNodeType(member.type, !!member.questionToken)}`);
+            }
+        }
+        if (properties.length > 0 && methods.length === 0) {
+            const fields = [...extendedInterfaces.map((e) => `\t${e}`), ...properties];
+            return `type ${name}${typeParams} struct {\n${fields.join('\n')}\n}`;
         }
         const members = [...extendedInterfaces.map((e) => `\t${e}`), ...methods];
         return `type ${name}${typeParams} interface {\n${members.join('\n')}\n}`;
@@ -286,7 +431,20 @@ export function visit(node, options = {}) {
     else if (ts.isClassDeclaration(node)) {
         if (options.addFunctionOutside) {
             outsideNodes.push(node);
-            classNames.add(visit(node.name));
+            const className = visit(node.name);
+            classNames.add(className);
+            const properties = new Map();
+            const methods = new Map();
+            for (const member of node.members) {
+                if (ts.isPropertyDeclaration(member) && ts.isIdentifier(member.name)) {
+                    properties.set(member.name.text, getOptionalNodeType(member.type, !!member.questionToken));
+                }
+                if (ts.isMethodDeclaration(member) && ts.isIdentifier(member.name)) {
+                    methods.set(member.name.text, member.type ? getType(member.type) : 'interface{}');
+                }
+            }
+            classPropertyTypes.set(className, properties);
+            classMethodReturnTypes.set(className, methods);
             return '';
         }
         const name = visit(node.name);
@@ -312,7 +470,7 @@ export function visit(node, options = {}) {
                     fieldType = `[]${getType(member.type, true)}`;
                 }
                 else {
-                    fieldType = member.type ? getType(member.type) : 'interface{}';
+                    fieldType = getOptionalNodeType(member.type, !!member.questionToken);
                 }
                 fields.push(`\t${fieldName} ${fieldType}`);
             }
@@ -320,7 +478,7 @@ export function visit(node, options = {}) {
         let result = `type ${name}${typeParams} struct {\n${fields.join('\n')}\n}\n\n`;
         const ctor = node.members.find((m) => ts.isConstructorDeclaration(m));
         if (ctor) {
-            const params = ctor.parameters.map((p) => `${visit(p.name)} ${getType(p.type)}`).join(', ');
+            const ctorParameterInfo = getFunctionParametersInfo(ctor.parameters);
             const bodyStatements = ctor.body?.statements
                 .filter((s) => {
                 if (ts.isExpressionStatement(s) && ts.isCallExpression(s.expression)) {
@@ -330,7 +488,7 @@ export function visit(node, options = {}) {
             })
                 .map((s) => visit(s))
                 .join('\t') ?? '';
-            result += `func New${name}${typeParams}(${params}) *${name}${typeParamNames} {\n\t\tself := &${name}${typeParamNames}{}\n\t\t${bodyStatements}return self;\n\t}\n\n`;
+            result += `func New${name}${typeParams}(${ctorParameterInfo.signature}) *${name}${typeParamNames} {\n\t\tself := &${name}${typeParamNames}{}\n\t\t${ctorParameterInfo.prefixBlockContent}${bodyStatements}return self;\n\t}\n\n`;
         }
         else {
             result += `func New${name}${typeParams}() *${name}${typeParamNames} {\n\t\treturn &${name}${typeParamNames}{}\n\t}\n\n`;
@@ -338,11 +496,11 @@ export function visit(node, options = {}) {
         for (const member of node.members) {
             if (ts.isMethodDeclaration(member)) {
                 const methodName = visit(member.name);
-                const params = member.parameters
-                    .map((p) => `${visit(p.name)} ${getType(p.type)}`)
-                    .join(', ');
+                const methodParameterInfo = getFunctionParametersInfo(member.parameters);
                 const returnType = member.type ? ` ${getType(member.type)}` : '';
-                result += `func (self *${name}${typeParamNames}) ${methodName}(${params})${returnType} ${visit(member.body)}\n\n`;
+                result += `func (self *${name}${typeParamNames}) ${methodName}(${methodParameterInfo.signature})${returnType} ${visit(member.body, {
+                    prefixBlockContent: methodParameterInfo.prefixBlockContent
+                })}\n\n`;
             }
         }
         return result.trim();
@@ -365,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(', ')})`;
@@ -408,9 +572,552 @@ function getTypeText(typeNode) {
     }
     return getType(typeNode);
 }
+function toGoStringLiteral(value) {
+    return JSON.stringify(value);
+}
+function visitTemplateExpression(node) {
+    const parts = [];
+    if (node.head.text.length > 0) {
+        parts.push(toGoStringLiteral(node.head.text));
+    }
+    for (const span of node.templateSpans) {
+        importedPackages.add('fmt');
+        parts.push(`fmt.Sprintf("%v", ${visit(span.expression)})`);
+        if (span.literal.text.length > 0) {
+            parts.push(toGoStringLiteral(span.literal.text));
+        }
+    }
+    if (parts.length === 0) {
+        return '""';
+    }
+    return parts.join(' + ');
+}
+function hasQuestionDot(node) {
+    return ('questionDotToken' in node &&
+        !!node.questionDotToken);
+}
+function getTempName(prefix) {
+    return `__${prefix}_${goSafeId()}__`;
+}
+function inferExpectedTypeFromContext(node) {
+    const parent = node.parent;
+    if (ts.isVariableDeclaration(parent) && parent.initializer === node && parent.type) {
+        return getType(parent.type);
+    }
+    if (ts.isReturnStatement(parent)) {
+        let scope = parent.parent;
+        while (scope) {
+            if (ts.isFunctionDeclaration(scope) ||
+                ts.isMethodDeclaration(scope) ||
+                ts.isFunctionExpression(scope) ||
+                ts.isArrowFunction(scope)) {
+                if (scope.type)
+                    return getType(scope.type);
+                break;
+            }
+            scope = scope.parent;
+        }
+    }
+    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))
+        return inferExpressionType(expr.expression);
+    if (ts.isAsExpression(expr))
+        return getType(expr.type);
+    if (ts.isTypeAssertionExpression(expr))
+        return getType(expr.type);
+    if (ts.isStringLiteral(expr) ||
+        ts.isNoSubstitutionTemplateLiteral(expr) ||
+        ts.isTemplateExpression(expr)) {
+        return 'string';
+    }
+    if (ts.isNumericLiteral(expr))
+        return 'float64';
+    if (expr.kind === ts.SyntaxKind.TrueKeyword || expr.kind === ts.SyntaxKind.FalseKeyword)
+        return 'bool';
+    if (expr.kind === ts.SyntaxKind.NullKeyword)
+        return 'nil';
+    if (ts.isIdentifier(expr))
+        return variableGoTypes.get(expr.text);
+    if (ts.isArrayLiteralExpression(expr)) {
+        if (expr.elements.length === 0)
+            return '[]interface{}';
+        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);
+            return enumType;
+        }
+        const leftType = inferExpressionType(expr.expression);
+        if (expr.name.text === 'length')
+            return 'float64';
+        const resolvedLeftType = leftType?.replace(/^\*/, '').replace(/\[.*\]$/, '');
+        const resolvedPropertyType = resolvedLeftType
+            ? (classPropertyTypes.get(resolvedLeftType)?.get(expr.name.text) ??
+                interfacePropertyTypes.get(resolvedLeftType)?.get(expr.name.text))
+            : undefined;
+        if (hasQuestionDot(expr)) {
+            if (leftType && leftType.startsWith('*')) {
+                const memberType = resolvedPropertyType ?? 'interface{}';
+                return makeNullableType(memberType);
+            }
+            return 'interface{}';
+        }
+        if (resolvedPropertyType) {
+            return resolvedPropertyType;
+        }
+        if (ts.isIdentifier(expr.expression)) {
+            const className = variableClassNames.get(expr.expression.text);
+            const memberType = className
+                ? classPropertyTypes.get(className)?.get(expr.name.text)
+                : undefined;
+            if (memberType)
+                return memberType;
+        }
+    }
+    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') {
+                const callback = expr.arguments[0];
+                const mappedType = callback
+                    ? inferArrayCallbackReturnType(callback, elementType, elementType)
+                    : elementType;
+                return `[]${mappedType}`;
+            }
+            if (methodName === 'filter')
+                return `[]${elementType}`;
+            if (methodName === 'some')
+                return 'bool';
+            if (methodName === 'find')
+                return elementType;
+            if (methodName === 'join')
+                return 'string';
+        }
+        if (ownerType && ownerType.startsWith('*')) {
+            const className = ownerType.replace(/^\*/, '').replace(/\[.*\]$/, '');
+            const returnType = classMethodReturnTypes.get(className)?.get(methodName);
+            if (returnType) {
+                if (hasQuestionDot(expr) || hasQuestionDot(expr.expression)) {
+                    return makeNullableType(returnType);
+                }
+                return returnType;
+            }
+        }
+        if (ts.isIdentifier(expr.expression.expression)) {
+            const className = variableClassNames.get(expr.expression.expression.text);
+            const returnType = className
+                ? classMethodReturnTypes.get(className)?.get(methodName)
+                : undefined;
+            if (returnType) {
+                if (hasQuestionDot(expr) || hasQuestionDot(expr.expression)) {
+                    return makeNullableType(returnType);
+                }
+                return returnType;
+            }
+        }
+    }
+    if (ts.isConditionalExpression(expr)) {
+        const whenTrueType = inferExpressionType(expr.whenTrue);
+        const whenFalseType = inferExpressionType(expr.whenFalse);
+        if (whenTrueType && whenTrueType === whenFalseType)
+            return whenTrueType;
+        return whenTrueType ?? whenFalseType;
+    }
+    if (ts.isBinaryExpression(expr) &&
+        expr.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
+        const leftType = inferExpressionType(expr.left);
+        const rightType = inferExpressionType(expr.right);
+        if (leftType && leftType.startsWith('*') && rightType === leftType.slice(1)) {
+            return rightType;
+        }
+        return rightType ?? leftType;
+    }
+    return undefined;
+}
+function makeNullableType(typeName) {
+    if (!typeName || typeName === 'interface{}' || typeName.startsWith('*'))
+        return typeName || 'interface{}';
+    if (['string', 'float64', 'bool'].includes(typeName))
+        return `*${typeName}`;
+    return typeName;
+}
+function visitConditionalExpression(node) {
+    const whenTrue = visit(node.whenTrue);
+    const whenFalse = visit(node.whenFalse);
+    const resultType = inferExpectedTypeFromContext(node) ||
+        (() => {
+            const whenTrueType = inferExpressionType(node.whenTrue);
+            const whenFalseType = inferExpressionType(node.whenFalse);
+            if (whenTrueType && whenTrueType === whenFalseType)
+                return whenTrueType;
+            return whenTrueType ?? whenFalseType ?? 'interface{}';
+        })();
+    return `func() ${resultType} { if ${visit(node.condition)} { return ${whenTrue} }; return ${whenFalse} }()`;
+}
+function visitNullishCoalescingExpression(node) {
+    const leftType = inferExpressionType(node.left);
+    const rightType = inferExpressionType(node.right);
+    if (leftType && leftType.startsWith('*')) {
+        const leftValueType = leftType.slice(1);
+        const expectedType = inferExpectedTypeFromContext(node);
+        const resultType = expectedType || (rightType === leftValueType ? leftValueType : (rightType ?? leftType));
+        const tmp = getTempName('nullish');
+        const leftExpr = visit(node.left);
+        const rightExpr = visit(node.right);
+        const returnLeft = resultType === leftValueType ? `*${tmp}` : tmp;
+        return `func() ${resultType} { ${tmp} := ${leftExpr}; if ${tmp} == nil { return ${rightExpr} }; return ${returnLeft} }()`;
+    }
+    return visit(node.left);
+}
+function visitOptionalPropertyAccess(node) {
+    const baseExpr = visit(node.expression);
+    const baseType = inferExpressionType(node.expression);
+    if (!baseType || !baseType.startsWith('*')) {
+        const objectType = resolveExpressionType(node.expression);
+        return getAcessString(baseExpr, visit(node.name), objectType);
+    }
+    const className = baseType.replace(/^\*/, '').replace(/\[.*\]$/, '');
+    const propertyType = classPropertyTypes.get(className)?.get(node.name.text) ?? 'interface{}';
+    const nullableType = makeNullableType(propertyType);
+    const tmp = getTempName('opt');
+    const propertyAccess = `${tmp}.${visit(node.name)}`;
+    if (nullableType.startsWith('*') && nullableType.slice(1) === propertyType) {
+        const valueTemp = getTempName('optv');
+        return `func() ${nullableType} { ${tmp} := ${baseExpr}; if ${tmp} == nil { var __zero ${nullableType}; return __zero }; ${valueTemp} := ${propertyAccess}; return &${valueTemp} }()`;
+    }
+    return `func() ${nullableType} { ${tmp} := ${baseExpr}; if ${tmp} == nil { var __zero ${nullableType}; return __zero }; return ${propertyAccess} }()`;
+}
+function visitOptionalElementAccess(node) {
+    const baseExpr = visit(node.expression);
+    const baseType = inferExpressionType(node.expression);
+    if (!baseType || !baseType.startsWith('*')) {
+        return `${baseExpr}[int(${visit(node.argumentExpression)})]`;
+    }
+    const valueType = inferExpectedTypeFromContext(node) ?? 'interface{}';
+    const nullableType = makeNullableType(valueType);
+    const tmp = getTempName('opte');
+    const elementExpr = `${tmp}[int(${visit(node.argumentExpression)})]`;
+    if (nullableType.startsWith('*') && nullableType.slice(1) === valueType) {
+        const valueTemp = getTempName('optev');
+        return `func() ${nullableType} { ${tmp} := ${baseExpr}; if ${tmp} == nil { var __zero ${nullableType}; return __zero }; ${valueTemp} := ${elementExpr}; return &${valueTemp} }()`;
+    }
+    return `func() ${nullableType} { ${tmp} := ${baseExpr}; if ${tmp} == nil { var __zero ${nullableType}; return __zero }; return ${elementExpr} }()`;
+}
+function visitOptionalCall(node) {
+    if (!ts.isPropertyAccessExpression(node.expression)) {
+        return `${visit(node.expression)}(${node.arguments.map((a) => visit(a)).join(', ')})`;
+    }
+    const baseNode = node.expression.expression;
+    const methodName = node.expression.name.text;
+    const baseExpr = visit(baseNode);
+    const baseType = inferExpressionType(baseNode);
+    const args = node.arguments.map((a) => visit(a)).join(', ');
+    if (!baseType || !baseType.startsWith('*')) {
+        return `${baseExpr}.${methodName}(${args})`;
+    }
+    const className = baseType.replace(/^\*/, '').replace(/\[.*\]$/, '');
+    const returnType = classMethodReturnTypes.get(className)?.get(methodName) ?? 'interface{}';
+    const nullableType = makeNullableType(returnType);
+    const tmp = getTempName('optc');
+    const callExpr = `${tmp}.${methodName}(${args})`;
+    if (nullableType.startsWith('*') && nullableType.slice(1) === returnType) {
+        const valueTemp = getTempName('optcv');
+        return `func() ${nullableType} { ${tmp} := ${baseExpr}; if ${tmp} == nil { var __zero ${nullableType}; return __zero }; ${valueTemp} := ${callExpr}; return &${valueTemp} }()`;
+    }
+    return `func() ${nullableType} { ${tmp} := ${baseExpr}; if ${tmp} == nil { var __zero ${nullableType}; return __zero }; return ${callExpr} }()`;
+}
+function isArrayLikeGoType(goType) {
+    return !!goType && goType.startsWith('[]');
+}
+function getArrayElementTypeFromGoType(goType) {
+    if (!goType.startsWith('[]'))
+        return 'interface{}';
+    const elementType = goType.slice(2);
+    return elementType || 'interface{}';
+}
+function inferArrayCallbackReturnType(callback, elementType, fallbackType) {
+    if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) {
+        if (callback.type) {
+            const explicitType = getType(callback.type);
+            return explicitType || fallbackType;
+        }
+        if (ts.isBlock(callback.body)) {
+            return fallbackType;
+        }
+        const inferred = inferExpressionType(callback.body);
+        return inferred ?? fallbackType;
+    }
+    if (ts.isIdentifier(callback)) {
+        const knownType = variableGoTypes.get(callback.text);
+        if (knownType)
+            return knownType;
+    }
+    return fallbackType;
+}
+function buildArrayCallbackInfo(callback, elementType, forcedReturnType) {
+    if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) {
+        const paramCount = callback.parameters.length;
+        const callbackReturnType = forcedReturnType ?? inferArrayCallbackReturnType(callback, elementType, 'interface{}');
+        const params = [];
+        if (paramCount > 0) {
+            params.push(`${visit(callback.parameters[0].name)} ${elementType}`);
+        }
+        if (paramCount > 1) {
+            params.push(`${visit(callback.parameters[1].name)} float64`);
+        }
+        if (paramCount > 2) {
+            params.push(`${visit(callback.parameters[2].name)} []${elementType}`);
+        }
+        const body = ts.isBlock(callback.body)
+            ? visit(callback.body)
+            : `{\n\t\treturn ${visit(callback.body)};\n\t}`;
+        return {
+            fnExpr: `func(${params.join(', ')}) ${callbackReturnType} ${body}`,
+            paramCount,
+            returnType: callbackReturnType
+        };
+    }
+    return {
+        fnExpr: visit(callback),
+        paramCount: 1,
+        returnType: forcedReturnType ?? 'interface{}'
+    };
+}
+function buildArrayCallbackInvocation(callbackInfo, itemVar, indexVar, arrayVar) {
+    const args = [];
+    if (callbackInfo.paramCount > 0)
+        args.push(itemVar);
+    if (callbackInfo.paramCount > 1)
+        args.push(`float64(${indexVar})`);
+    if (callbackInfo.paramCount > 2)
+        args.push(arrayVar);
+    return `(${callbackInfo.fnExpr})(${args.join(', ')})`;
+}
+function visitArrayHigherOrderCall(node) {
+    if (!ts.isPropertyAccessExpression(node.expression))
+        return undefined;
+    const methodName = node.expression.name.text;
+    if (!['map', 'filter', 'some', 'find', 'join'].includes(methodName)) {
+        return undefined;
+    }
+    const arrayExprNode = node.expression.expression;
+    const arrayExpr = visit(arrayExprNode);
+    const ownerType = inferExpressionType(arrayExprNode);
+    const elementType = isArrayLikeGoType(ownerType)
+        ? getArrayElementTypeFromGoType(ownerType)
+        : 'interface{}';
+    if (methodName === 'join') {
+        importedPackages.add('strings');
+        importedPackages.add('fmt');
+        const separator = node.arguments[0] ? visit(node.arguments[0]) : '""';
+        const arrVar = getTempName('arrjoin');
+        const partsVar = getTempName('parts');
+        return `func() string { ${arrVar} := ${arrayExpr}; ${partsVar} := make([]string, len(${arrVar})); for i, v := range ${arrVar} { ${partsVar}[i] = fmt.Sprintf("%v", v) }; return strings.Join(${partsVar}, ${separator}) }()`;
+    }
+    const callback = node.arguments[0];
+    if (!callback) {
+        return undefined;
+    }
+    const arrVar = getTempName('arrhof');
+    const idxVar = getTempName('i');
+    const itemVar = getTempName('item');
+    if (methodName === 'map') {
+        const callbackInfo = buildArrayCallbackInfo(callback, elementType, elementType);
+        const mappedType = callbackInfo.returnType || 'interface{}';
+        const resultVar = getTempName('mapres');
+        const rangeIndexVar = callbackInfo.paramCount > 1 ? idxVar : '_';
+        const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
+        return `func() []${mappedType} { ${arrVar} := ${arrayExpr}; ${resultVar} := make([]${mappedType}, 0, len(${arrVar})); for ${rangeIndexVar}, ${itemVar} := range ${arrVar} { ${resultVar} = append(${resultVar}, ${callbackCall}) }; return ${resultVar} }()`;
+    }
+    if (methodName === 'filter') {
+        const callbackInfo = buildArrayCallbackInfo(callback, elementType, 'bool');
+        const resultVar = getTempName('filterres');
+        const rangeIndexVar = callbackInfo.paramCount > 1 ? idxVar : '_';
+        const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
+        return `func() []${elementType} { ${arrVar} := ${arrayExpr}; ${resultVar} := make([]${elementType}, 0, len(${arrVar})); for ${rangeIndexVar}, ${itemVar} := range ${arrVar} { if ${callbackCall} { ${resultVar} = append(${resultVar}, ${itemVar}) } }; return ${resultVar} }()`;
+    }
+    if (methodName === 'some') {
+        const callbackInfo = buildArrayCallbackInfo(callback, elementType, 'bool');
+        const rangeIndexVar = callbackInfo.paramCount > 1 ? idxVar : '_';
+        const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
+        return `func() bool { ${arrVar} := ${arrayExpr}; for ${rangeIndexVar}, ${itemVar} := range ${arrVar} { if ${callbackCall} { return true } }; return false }()`;
+    }
+    const callbackInfo = buildArrayCallbackInfo(callback, elementType, 'bool');
+    const rangeIndexVar = callbackInfo.paramCount > 1 ? idxVar : '_';
+    const callbackCall = buildArrayCallbackInvocation(callbackInfo, itemVar, idxVar, arrVar);
+    return `func() ${elementType} { ${arrVar} := ${arrayExpr}; for ${rangeIndexVar}, ${itemVar} := range ${arrVar} { if ${callbackCall} { return ${itemVar} } }; var __zero ${elementType}; return __zero }()`;
+}
+function getAliasType(name, seen = new Set()) {
+    const aliasType = typeAliases.get(name);
+    if (!aliasType)
+        return undefined;
+    if (seen.has(name))
+        return undefined;
+    if (ts.isTypeReferenceNode(aliasType) && ts.isIdentifier(aliasType.typeName)) {
+        const nestedName = aliasType.typeName.text;
+        if (typeAliases.has(nestedName)) {
+            seen.add(name);
+            return getAliasType(nestedName, seen) ?? aliasType;
+        }
+    }
+    return aliasType;
+}
+function getOptionalNodeType(typeNode, isOptional) {
+    const baseType = typeNode ? getType(typeNode) : 'interface{}';
+    if (!isOptional)
+        return baseType;
+    if (baseType === 'interface{}' || baseType.startsWith('*'))
+        return baseType;
+    if (['string', 'float64', 'bool'].includes(baseType))
+        return `*${baseType}`;
+    return baseType;
+}
+function getEnumMemberName(name) {
+    if (ts.isIdentifier(name)) {
+        return getSafeName(name.text);
+    }
+    if (ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
+        const sanitized = name.text.replace(/[^a-zA-Z0-9_]/g, '_');
+        return sanitized.length > 0 ? sanitized : 'Member';
+    }
+    return 'Member';
+}
+function getEnumBaseType(node) {
+    for (const member of node.members) {
+        const initializer = member.initializer;
+        if (!initializer)
+            continue;
+        if (ts.isStringLiteral(initializer) || ts.isNoSubstitutionTemplateLiteral(initializer)) {
+            return 'string';
+        }
+    }
+    return 'float64';
+}
+function readNumericEnumInitializer(initializer) {
+    if (ts.isNumericLiteral(initializer)) {
+        return Number(initializer.text);
+    }
+    if (ts.isPrefixUnaryExpression(initializer) &&
+        initializer.operator === ts.SyntaxKind.MinusToken &&
+        ts.isNumericLiteral(initializer.operand)) {
+        return -Number(initializer.operand.text);
+    }
+    return undefined;
+}
+function visitEnumDeclaration(node) {
+    const enumName = getSafeName(node.name.text);
+    const baseType = enumBaseTypes.get(node.name.text) ?? getEnumBaseType(node);
+    let nextNumericValue = 0;
+    let canAutoIncrement = true;
+    const members = [];
+    for (const member of node.members) {
+        const memberName = getEnumMemberName(member.name);
+        const symbolName = `${enumName}_${memberName}`;
+        let valueExpr;
+        if (member.initializer) {
+            if (baseType === 'float64') {
+                const numericValue = readNumericEnumInitializer(member.initializer);
+                if (numericValue !== undefined) {
+                    valueExpr = `${numericValue}`;
+                    nextNumericValue = numericValue + 1;
+                    canAutoIncrement = true;
+                }
+                else {
+                    valueExpr = `float64(${visit(member.initializer)})`;
+                    canAutoIncrement = false;
+                }
+            }
+            else {
+                valueExpr = visit(member.initializer);
+            }
+        }
+        else if (baseType === 'float64') {
+            const currentValue = canAutoIncrement ? nextNumericValue : 0;
+            valueExpr = `${currentValue}`;
+            nextNumericValue = currentValue + 1;
+        }
+        else {
+            valueExpr = toGoStringLiteral(memberName);
+        }
+        members.push(`\t${symbolName} ${enumName} = ${enumName}(${valueExpr})`);
+    }
+    return `type ${enumName} ${baseType}\n\nvar (\n${members.join('\n')}\n)`;
+}
 function getType(typeNode, getArrayType = false) {
     if (!typeNode)
         return ':';
+    if (ts.isArrayTypeNode(typeNode)) {
+        const elementType = getType(typeNode.elementType);
+        return getArrayType ? elementType : `[]${elementType}`;
+    }
     // Handle union types (e.g. string | null, number | undefined)
     if (ts.isUnionTypeNode(typeNode)) {
         const nonNullTypes = typeNode.types.filter((t) => t.kind !== ts.SyntaxKind.NullKeyword &&
@@ -428,14 +1135,37 @@ 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)) {
+            return getSafeName(name);
+        }
+        const aliasType = getAliasType(name);
+        if (aliasType) {
+            return getType(aliasType, getArrayType);
+        }
         if (name === 'Promise' && typeNode.typeArguments && typeNode.typeArguments.length > 0) {
             return `chan ${getType(typeNode.typeArguments[0])}`;
         }
         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}`;
@@ -486,12 +1216,30 @@ 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;
     }
     return undefined;
 }
+function getClassNameFromTypeNode(typeNode) {
+    if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
+        return classNames.has(typeNode.typeName.text) ? typeNode.typeName.text : undefined;
+    }
+    if (ts.isUnionTypeNode(typeNode)) {
+        const nonNullTypes = typeNode.types.filter((t) => t.kind !== ts.SyntaxKind.NullKeyword &&
+            t.kind !== ts.SyntaxKind.UndefinedKeyword &&
+            !(ts.isLiteralTypeNode(t) && t.literal.kind === ts.SyntaxKind.NullKeyword));
+        if (nonNullTypes.length === 1) {
+            return getClassNameFromTypeNode(nonNullTypes[0]);
+        }
+    }
+    return undefined;
+}
 function resolveExpressionType(expr) {
     if (ts.isIdentifier(expr)) {
         return variableTypes.get(expr.text);
@@ -512,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 = {
@@ -667,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]}`;
@@ -695,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 =
@@ -772,6 +1548,59 @@ function getTypeArguments(typeArguments) {
     const args = typeArguments.map((ta) => getType(ta));
     return `[${args.join(', ')}]`;
 }
+function getParameterGoType(param) {
+    if (param.type) {
+        const explicitType = getType(param.type);
+        return explicitType === ':' ? 'interface{}' : explicitType;
+    }
+    if (param.initializer) {
+        const inferredType = inferExpressionType(param.initializer);
+        if (inferredType && inferredType !== 'nil' && inferredType !== ':') {
+            return inferredType;
+        }
+    }
+    return 'interface{}';
+}
+function getFunctionParametersInfo(parameters) {
+    if (parameters.length === 0) {
+        return { signature: '', prefixBlockContent: '' };
+    }
+    const firstDefaultIndex = parameters.findIndex((p) => !!p.initializer);
+    if (firstDefaultIndex === -1) {
+        return {
+            signature: parameters.map((p) => `${visit(p.name)} ${getParameterGoType(p)}`).join(', '),
+            prefixBlockContent: ''
+        };
+    }
+    const hasRequiredAfterDefault = parameters
+        .slice(firstDefaultIndex)
+        .some((p) => !p.initializer);
+    if (hasRequiredAfterDefault) {
+        return {
+            signature: parameters.map((p) => `${visit(p.name)} ${getParameterGoType(p)}`).join(', '),
+            prefixBlockContent: ''
+        };
+    }
+    const requiredParams = parameters.slice(0, firstDefaultIndex);
+    const defaultedParams = parameters.slice(firstDefaultIndex);
+    const signatureParts = requiredParams.map((p) => `${visit(p.name)} ${getParameterGoType(p)}`);
+    signatureParts.push('__defaultArgs ...interface{}');
+    const prefixBlockContent = defaultedParams
+        .map((param, index) => {
+        const paramName = visit(param.name);
+        const paramType = getParameterGoType(param);
+        const defaultValue = visit(param.initializer);
+        if (paramType === 'interface{}') {
+            return `var ${paramName} interface{}\n\t\tif len(__defaultArgs) > ${index} {\n\t\t\t${paramName} = __defaultArgs[${index}]\n\t\t} else {\n\t\t\t${paramName} = ${defaultValue}\n\t\t}\n\t\t`;
+        }
+        return `var ${paramName} ${paramType}\n\t\tif len(__defaultArgs) > ${index} {\n\t\t\t${paramName} = __defaultArgs[${index}].(${paramType})\n\t\t} else {\n\t\t\t${paramName} = ${defaultValue}\n\t\t}\n\t\t`;
+    })
+        .join('');
+    return {
+        signature: signatureParts.join(', '),
+        prefixBlockContent
+    };
+}
 function getSafeName(name) {
     if (!dangerousNames.has(name)) {
         return name;
@@ -831,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');
+}