typescript-to-gdscript 0.1.0

package/dist/converter/ts-to-gd/imports.js

@@ -0,0 +1,150 @@
+/**
+ * TS→GD import processing.
+ *
+ * Translates `import { … } from '…'` statements at the top of a TS source
+ * file into the GDScript output, following the project's anonymous-class
+ * convention:
+ *
+ *   - Non-anonymous (regular `class_name X`) class, no rename →
+ *     skip emission. The class is globally available in GD by virtue of
+ *     `class_name`; no `const` alias needed.
+ *
+ *   - Non-anonymous, renamed (`import { Foo as Bar }`) →
+ *     `const Bar = preload("res://path/to/Foo.gd")` so the local TS
+ *     identifier resolves to the same script in GD.
+ *
+ *   - Anonymous (`_FilenameClass` — see `gdFilenameToAnonymousClassName`)
+ *     class, with or without rename →
+ *     `const <local> = preload("res://path/to/file.gd")`. Anonymous
+ *     classes have no `class_name`, so a `const` alias is the only way
+ *     to refer to them at all.
+ *
+ *   - `import X from '…'` (default) and `import * as X from '…'`
+ *     (namespace) → hard error. GDScript has no equivalent.
+ *
+ *   - `import type { … }` and per-binding `import { type X }` →
+ *     skip silently (TS-only, erased at runtime).
+ *
+ * The collected `consts` list is emitted by the transformer right after
+ * `class_name`/`extends`. The `importMap` is consulted later for the
+ * `extends "res://…"` rewrite (when extending an anonymous class) and
+ * for field-name conflict detection.
+ */
+import ts from 'typescript';
+import { dirname, relative, resolve } from 'path';
+import { isAnonymousClassName, } from "../common/index.js";
+export function processImports(sourceFile, ctx) {
+    const consts = [];
+    const importMap = new Map();
+    const errors = [];
+    for (const stmt of sourceFile.statements) {
+        if (!ts.isImportDeclaration(stmt))
+            continue;
+        // Whole-import `import type { … }` is TS-only — drop entirely.
+        if (stmt.importClause?.isTypeOnly)
+            continue;
+        const clause = stmt.importClause;
+        if (!clause) {
+            // `import "./side-effect"` — no bindings, nothing to translate.
+            continue;
+        }
+        // Default import: `import X from '…'` — unsupported.
+        if (clause.name) {
+            errors.push(diagOf(ctx, clause.name, `Default imports are not supported in TS→GD (no GDScript equivalent). Use \`import { X } from '...'\` instead.`));
+            // Continue processing named bindings on the same statement, if any.
+        }
+        // Namespace import: `import * as X from '…'` — unsupported.
+        if (clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) {
+            errors.push(diagOf(ctx, clause.namedBindings, `Namespace imports (\`import * as X\`) are not supported in TS→GD (GDScript has no module namespace).`));
+            continue;
+        }
+        if (!clause.namedBindings || !ts.isNamedImports(clause.namedBindings)) {
+            continue;
+        }
+        // Resolve the import specifier to an absolute `.ts` path.
+        const specifier = stmt.moduleSpecifier;
+        if (!ts.isStringLiteral(specifier))
+            continue;
+        const targetTsPath = resolveImportToTsPath(specifier.text, sourceFile.fileName);
+        if (!targetTsPath)
+            continue; // Bare module / unresolvable — type-only assumption.
+        // Compute the corresponding `.gd` path and `res://` form.
+        const resPath = computeResPath(targetTsPath, ctx);
+        for (const element of clause.namedBindings.elements) {
+            // Per-binding `import { type Foo, Bar }` — skip the type-only one.
+            if (element.isTypeOnly)
+                continue;
+            // `localName` is what the rest of the TS source uses; `importedName`
+            // is what the target module exports (== localName when no `as`).
+            const localName = element.name.text;
+            const importedName = element.propertyName?.text ?? localName;
+            const isAnonymous = isAnonymousClassName(importedName);
+            const renamed = element.propertyName !== undefined;
+            if (!isAnonymous && !renamed) {
+                // Regular global GD class — no `const` needed; the user's TS
+                // refers to it by the same name GD knows it as.
+                continue;
+            }
+            consts.push(`const ${localName} = preload("${resPath}")`);
+            importMap.set(localName, {
+                importedName,
+                isAnonymous,
+                resPath,
+                node: element,
+            });
+        }
+    }
+    return { consts, importMap, errors };
+}
+// ─── Path helpers ───────────────────────────────────────────────
+/**
+ * Resolve an import specifier (`'./foo.ts'`, `'./foo'`, `'../bar'`) to
+ * an absolute `.ts` file path. Returns `undefined` for bare module
+ * specifiers (`'react'`, `'@scope/pkg'`) — those can't represent a TS
+ * file in this project so we silently ignore them (the TS type checker
+ * will catch any actual misuse).
+ */
+function resolveImportToTsPath(specifier, fromFilePath) {
+    if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
+        return undefined;
+    }
+    const fromDir = dirname(fromFilePath);
+    const abs = resolve(fromDir, specifier);
+    // Strip a `.js` extension (TS NodeNext prefers `.js` in imports for `.ts` files).
+    if (abs.endsWith('.js'))
+        return abs.slice(0, -3) + '.ts';
+    if (abs.endsWith('.ts'))
+        return abs;
+    return abs + '.ts';
+}
+/**
+ * Convert an absolute `.ts` path into a `res://`-prefixed forward-slash
+ * path pointing at the corresponding `.gd` file. Path mirrors the
+ * relative tree from {@link TransformContext.tsDir} to
+ * {@link TransformContext.gdDir} and is then taken relative to
+ * {@link TransformContext.projectRoot}.
+ *
+ * When `tsDir`/`gdDir` are the same directory, this collapses to a
+ * trivial `.ts` → `.gd` extension swap.
+ */
+function computeResPath(targetTsPath, ctx) {
+    // 1. relative from tsDir → mirror under gdDir
+    const relTs = relative(ctx.tsDir, targetTsPath).replace(/\\/g, '/');
+    const relGd = relTs.replace(/\.ts$/, '.gd');
+    const absGd = resolve(ctx.gdDir, relGd);
+    // 2. relative from projectRoot → res://...
+    const relFromProject = relative(ctx.projectRoot, absGd).replace(/\\/g, '/');
+    return `res://${relFromProject}`;
+}
+// ─── Diagnostic helper ──────────────────────────────────────────
+function diagOf(ctx, node, message) {
+    const { line, character } = ctx.sourceFile.getLineAndCharacterOfPosition(node.getStart(ctx.sourceFile));
+    return {
+        message,
+        severity: 'error',
+        file: ctx.filePath,
+        line: line + 1,
+        column: character + 1,
+    };
+}
+//# sourceMappingURL=imports.js.map

package/dist/converter/ts-to-gd/imports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"imports.js","sourceRoot":"","sources":["../../../src/converter/ts-to-gd/imports.ts"],"names":[],"mappings":"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"}

package/dist/converter/ts-to-gd/index.d.ts

@@ -0,0 +1,34 @@
+import ts from 'typescript';
+import type { TransformResult } from '../common/index.ts';
+export interface ConvertOptions {
+    /** Path to the TypeScript file */
+    filePath: string;
+    /** Root directory of the project */
+    rootDir: string;
+    /**
+     * TypeScript source root (where consumer `.ts` files live). Used to
+     * compute the mirrored `.gd` path for imported classes when emitting
+     * `const X = preload("res://…")` and `extends "res://…"`. Defaults to
+     * `rootDir` (TS and GD trees share the same root).
+     */
+    tsDir?: string;
+    /**
+     * GDScript output root. Combined with `tsDir` to mirror the relative
+     * tree structure when computing import paths. Defaults to `rootDir`.
+     */
+    gdDir?: string;
+    /**
+     * Godot project root — `res://` paths in emitted `preload(...)` and
+     * `extends "res://..."` are taken relative to this directory. Defaults
+     * to `rootDir`.
+     */
+    projectRoot?: string;
+    /** Path to tsconfig.json */
+    tsConfigPath?: string;
+    /** Whether to generate source maps */
+    sourceMap?: boolean;
+    /** Pre-created TypeScript program (for batch mode) */
+    program?: ts.Program;
+}
+export declare function convertTsToGd(options: ConvertOptions): TransformResult;
+//# sourceMappingURL=index.d.ts.map

package/dist/converter/ts-to-gd/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/converter/ts-to-gd/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAG5B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAI1D,MAAM,WAAW,cAAc;IAC7B,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,oCAAoC;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4BAA4B;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,sCAAsC;IACtC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,sDAAsD;IACtD,OAAO,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC;CACtB;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,eAAe,CAoDtE"}

package/dist/converter/ts-to-gd/index.js

@@ -0,0 +1,52 @@
+import ts from 'typescript';
+import { createTsProgram } from "../../parser/typescript/index.js";
+import { resolveRegistry } from "../../config/index.js";
+import { TsToGdTransformer } from "./transformer.js";
+import { buildDiagnosticsTypeInfo } from "./diagnostics.js";
+export function convertTsToGd(options) {
+    const program = options.program ??
+        createTsProgram({
+            rootDir: options.rootDir,
+            files: [options.filePath],
+            tsConfigPath: options.tsConfigPath,
+        });
+    const sourceFile = program.getSourceFile(options.filePath);
+    if (!sourceFile) {
+        return {
+            code: '',
+            diagnostics: [
+                {
+                    message: `File not found: ${options.filePath}`,
+                    severity: 'error',
+                    file: options.filePath,
+                    line: 0,
+                    column: 0,
+                },
+            ],
+        };
+    }
+    // Registry is optional — if unavailable, diagnostics fall back to primitive checks only.
+    let registry;
+    try {
+        registry = resolveRegistry();
+    }
+    catch {
+        /* registry unavailable */
+    }
+    const diagInfo = buildDiagnosticsTypeInfo(registry);
+    const transformer = new TsToGdTransformer({
+        program,
+        checker: program.getTypeChecker(),
+        sourceFile,
+        filePath: options.filePath,
+        diagnostics: [],
+        diagInfo,
+        tsDir: options.tsDir ?? options.rootDir,
+        gdDir: options.gdDir ?? options.rootDir,
+        projectRoot: options.projectRoot ?? options.rootDir,
+    }, {
+        sourceMap: options.sourceMap ?? false,
+    });
+    return transformer.transform();
+}
+//# sourceMappingURL=index.js.map

package/dist/converter/ts-to-gd/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/converter/ts-to-gd/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,OAAO,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC;AAiC5D,MAAM,UAAU,aAAa,CAAC,OAAuB;IACnD,MAAM,OAAO,GACX,OAAO,CAAC,OAAO;QACf,eAAe,CAAC;YACd,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,KAAK,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC;YACzB,YAAY,EAAE,OAAO,CAAC,YAAY;SACnC,CAAC,CAAC;IAEL,MAAM,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC3D,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,OAAO;YACL,IAAI,EAAE,EAAE;YACR,WAAW,EAAE;gBACX;oBACE,OAAO,EAAE,mBAAmB,OAAO,CAAC,QAAQ,EAAE;oBAC9C,QAAQ,EAAE,OAAO;oBACjB,IAAI,EAAE,OAAO,CAAC,QAAQ;oBACtB,IAAI,EAAE,CAAC;oBACP,MAAM,EAAE,CAAC;iBACV;aACF;SACF,CAAC;IACJ,CAAC;IAED,yFAAyF;IACzF,IAAI,QAAQ,CAAC;IACb,IAAI,CAAC;QACH,QAAQ,GAAG,eAAe,EAAE,CAAC;IAC/B,CAAC;IAAC,MAAM,CAAC;QACP,0BAA0B;IAC5B,CAAC;IACD,MAAM,QAAQ,GAAG,wBAAwB,CAAC,QAAQ,CAAC,CAAC;IAEpD,MAAM,WAAW,GAAG,IAAI,iBAAiB,CACvC;QACE,OAAO;QACP,OAAO,EAAE,OAAO,CAAC,cAAc,EAAE;QACjC,UAAU;QACV,QAAQ,EAAE,OAAO,CAAC,QAAQ;QAC1B,WAAW,EAAE,EAAE;QACf,QAAQ;QACR,KAAK,EAAE,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,OAAO;QACvC,KAAK,EAAE,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC,OAAO;QACvC,WAAW,EAAE,OAAO,CAAC,WAAW,IAAI,OAAO,CAAC,OAAO;KACpD,EACD;QACE,SAAS,EAAE,OAAO,CAAC,SAAS,IAAI,KAAK;KACtC,CACF,CAAC;IAEF,OAAO,WAAW,CAAC,SAAS,EAAE,CAAC;AACjC,CAAC"}

package/dist/converter/ts-to-gd/parameters.d.ts

@@ -0,0 +1,12 @@
+import ts from 'typescript';
+import type { TransformerDelegate } from './transformer-types.ts';
+/** Check a type node for `undefined` keyword and emit a diagnostic. */
+export declare function checkTypeForUndefined(t: TransformerDelegate, typeNode: ts.TypeNode): void;
+/** Check if a resolved TS type contains `undefined` (for runtime value checks). */
+export declare function typeContainsUndefined(type: ts.Type): boolean;
+/**
+ * Emit a parameter list as a GDScript parameter string.
+ * Handles optional/null/vararg/undefined semantics.
+ */
+export declare function emitParameters(t: TransformerDelegate, params: ts.NodeArray<ts.ParameterDeclaration>): string;
+//# sourceMappingURL=parameters.d.ts.map

package/dist/converter/ts-to-gd/parameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameters.d.ts","sourceRoot":"","sources":["../../../src/converter/ts-to-gd/parameters.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAG5B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAElE,uEAAuE;AACvE,wBAAgB,qBAAqB,CACnC,CAAC,EAAE,mBAAmB,EACtB,QAAQ,EAAE,EAAE,CAAC,QAAQ,GACpB,IAAI,CAmBN;AAED,mFAAmF;AACnF,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,OAAO,CAM5D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,mBAAmB,EACtB,MAAM,EAAE,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,oBAAoB,CAAC,GAC5C,MAAM,CA+FR"}

package/dist/converter/ts-to-gd/parameters.js

@@ -0,0 +1,100 @@
+import ts from 'typescript';
+import { tsTypeNodeToGdType } from "../common/index.js";
+import { isGdClassType, isGdVariantType } from "./diagnostics.js";
+/** Check a type node for `undefined` keyword and emit a diagnostic. */
+export function checkTypeForUndefined(t, typeNode) {
+    if (typeNode.kind === ts.SyntaxKind.UndefinedKeyword) {
+        t.addDiagnostic(typeNode, 'type-error', '`undefined` type is not supported in GDScript; use `null` instead');
+    }
+    if (ts.isUnionTypeNode(typeNode)) {
+        for (const u of typeNode.types) {
+            if (u.kind === ts.SyntaxKind.UndefinedKeyword) {
+                t.addDiagnostic(u, 'type-error', '`undefined` type is not supported in GDScript; use `null` instead');
+            }
+        }
+    }
+}
+/** Check if a resolved TS type contains `undefined` (for runtime value checks). */
+export function typeContainsUndefined(type) {
+    if (type.flags & ts.TypeFlags.Undefined)
+        return true;
+    if (type.isUnion()) {
+        return type.types.some((u) => !!(u.flags & ts.TypeFlags.Undefined));
+    }
+    return false;
+}
+/**
+ * Emit a parameter list as a GDScript parameter string.
+ * Handles optional/null/vararg/undefined semantics.
+ */
+export function emitParameters(t, params) {
+    return params
+        .map((p) => {
+        const name = p.name.getText(t.ctx.sourceFile);
+        const isRest = !!p.dotDotDotToken;
+        // Check for `undefined` in type annotations (type position, not value)
+        if (p.type) {
+            checkTypeForUndefined(t, p.type);
+        }
+        if (isRest) {
+            // Rest parameter: `...args: Type[]` -> `...args: Array` or `...args`
+            // GDScript varargs use `...name` or `...name: Array`
+            let gdType = null;
+            if (p.type) {
+                // Strip array wrapper: `any[]` -> null, `Type[]` -> Array, `Array<Type>` -> Array
+                const typeText = p.type.getText(t.ctx.sourceFile);
+                if (typeText === 'any[]' || typeText === 'unknown[]') {
+                    gdType = null;
+                }
+                else {
+                    gdType = 'Array';
+                }
+            }
+            const typeAnnotation = gdType ? `: ${gdType}` : '';
+            return `...${name}${typeAnnotation}`;
+        }
+        const isNullDefault = p.initializer?.kind === ts.SyntaxKind.NullKeyword;
+        // Check if the type is a union containing null (e.g. `Node | null`, `null | Node2D`)
+        const isNullableUnion = p.type &&
+            ts.isUnionTypeNode(p.type) &&
+            p.type.types.some((u) => u.kind === ts.SyntaxKind.NullKeyword ||
+                (ts.isLiteralTypeNode(u) &&
+                    u.literal.kind === ts.SyntaxKind.NullKeyword));
+        // For nullable unions, strip `| null` and use the base type
+        let gdType = null;
+        if (p.type && isNullableUnion) {
+            const nonNullTypes = p.type.types.filter((u) => u.kind !== ts.SyntaxKind.NullKeyword &&
+                !(ts.isLiteralTypeNode(u) &&
+                    u.literal.kind === ts.SyntaxKind.NullKeyword));
+            if (nonNullTypes.length === 1) {
+                gdType = tsTypeNodeToGdType(nonNullTypes[0], t.ctx.checker, t.ctx.sourceFile, t.currentClassName);
+            }
+            // Multi-type union (e.g. Node | Node2D | null) -- can't express in GD
+        }
+        else {
+            gdType = tsTypeNodeToGdType(p.type, t.ctx.checker, t.ctx.sourceFile, t.currentClassName);
+        }
+        // Nullable param with `?` or `= null` -> `= null` in GDScript.
+        // Add type annotation only for class types (not primitives/variant types).
+        const needsNullDefault = (p.questionToken && !p.initializer) || isNullDefault;
+        if (needsNullDefault) {
+            if (gdType && isGdClassType(gdType, t.ctx.diagInfo)) {
+                return `${name}: ${gdType} = null`;
+            }
+            return `${name} = null`;
+        }
+        const defaultValue = p.initializer
+            ? ` = ${t.emitExpression(p.initializer)}`
+            : '';
+        // Omit type annotation for variant/constructor types with non-null defaults
+        // (GDScript infers type from the constructor call, e.g. Vector2.DOWN -> Vector2)
+        const omitType = gdType &&
+            p.initializer &&
+            !isNullDefault &&
+            isGdVariantType(gdType, t.ctx.diagInfo);
+        const typeAnnotation = gdType && !omitType ? `: ${gdType}` : '';
+        return `${name}${typeAnnotation}${defaultValue}`;
+    })
+        .join(', ');
+}
+//# sourceMappingURL=parameters.js.map

package/dist/converter/ts-to-gd/parameters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameters.js","sourceRoot":"","sources":["../../../src/converter/ts-to-gd/parameters.ts"],"names":[],"mappings":"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"}

package/dist/converter/ts-to-gd/statements.d.ts

@@ -0,0 +1,12 @@
+import ts from 'typescript';
+import type { TransformerDelegate } from './transformer-types.ts';
+export declare function visitBlock(t: TransformerDelegate, block: ts.Block): void;
+export declare function visitStatement(t: TransformerDelegate, node: ts.Statement): void;
+export declare function visitVariableStatement(t: TransformerDelegate, node: ts.VariableStatement): void;
+export declare function visitIfStatement(t: TransformerDelegate, node: ts.IfStatement): void;
+export declare function visitForOfStatement(t: TransformerDelegate, node: ts.ForOfStatement): void;
+export declare function visitForStatement(t: TransformerDelegate, node: ts.ForStatement): void;
+export declare function visitWhileStatement(t: TransformerDelegate, node: ts.WhileStatement): void;
+export declare function visitSwitchStatement(t: TransformerDelegate, node: ts.SwitchStatement): void;
+export declare function visitStatementBody(t: TransformerDelegate, node: ts.Statement): void;
+//# sourceMappingURL=statements.d.ts.map

package/dist/converter/ts-to-gd/statements.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"statements.d.ts","sourceRoot":"","sources":["../../../src/converter/ts-to-gd/statements.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAU5B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAIlE,wBAAgB,UAAU,CAAC,CAAC,EAAE,mBAAmB,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,IAAI,CAexE;AAED,wBAAgB,cAAc,CAC5B,CAAC,EAAE,mBAAmB,EACtB,IAAI,EAAE,EAAE,CAAC,SAAS,GACjB,IAAI,CAmDN;AAID,wBAAgB,sBAAsB,CACpC,CAAC,EAAE,mBAAmB,EACtB,IAAI,EAAE,EAAE,CAAC,iBAAiB,GACzB,IAAI,CA2EN;AAID,wBAAgB,gBAAgB,CAC9B,CAAC,EAAE,mBAAmB,EACtB,IAAI,EAAE,EAAE,CAAC,WAAW,GACnB,IAAI,CAkCN;AA2BD,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,mBAAmB,EACtB,IAAI,EAAE,EAAE,CAAC,cAAc,GACtB,IAAI,CAUN;AAED,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,mBAAmB,EACtB,IAAI,EAAE,EAAE,CAAC,YAAY,GACpB,IAAI,CA6BN;AAID,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,mBAAmB,EACtB,IAAI,EAAE,EAAE,CAAC,cAAc,GACtB,IAAI,CAUN;AAID,wBAAgB,oBAAoB,CAClC,CAAC,EAAE,mBAAmB,EACtB,IAAI,EAAE,EAAE,CAAC,eAAe,GACvB,IAAI,CA2CN;AAID,wBAAgB,kBAAkB,CAChC,CAAC,EAAE,mBAAmB,EACtB,IAAI,EAAE,EAAE,CAAC,SAAS,GACjB,IAAI,CAcN"}

package/dist/converter/ts-to-gd/statements.js

@@ -0,0 +1,262 @@
+import ts from 'typescript';
+import { tsTypeNodeToGdType } from "../common/index.js";
+import { isGdEvalCall, processGdEval, emitGdEval, isGdMatchCall, visitGdMatchStatement, emitMatchPatternExpr, } from "./gd-helpers.js";
+// ---- Block / Statement Visitors ----
+export function visitBlock(t, block) {
+    if (block.statements.length === 0) {
+        const pos = t.getLineAndCol(block);
+        t.emitter.writeLine('pass', pos.line, pos.col);
+        return;
+    }
+    for (const stmt of block.statements) {
+        t.emitLeadingComments(stmt);
+        visitStatement(t, stmt);
+    }
+    // Emit trailing comments before the closing brace
+    const closeBrace = block.getLastToken();
+    if (closeBrace) {
+        t.emitLeadingComments(closeBrace);
+    }
+}
+export function visitStatement(t, node) {
+    const pos = t.getLineAndCol(node);
+    if (ts.isVariableStatement(node)) {
+        visitVariableStatement(t, node);
+    }
+    else if (ts.isExpressionStatement(node)) {
+        if (isGdEvalCall(node.expression)) {
+            emitGdEval(t, node.expression, pos);
+        }
+        else if (isGdMatchCall(node.expression)) {
+            visitGdMatchStatement(t, node.expression, visitStatement);
+        }
+        else {
+            t.emitter.writeLine(t.emitExpression(node.expression), pos.line, pos.col);
+        }
+    }
+    else if (ts.isReturnStatement(node)) {
+        const expr = node.expression ? ` ${t.emitExpression(node.expression)}` : '';
+        t.emitter.writeLine(`return${expr}`, pos.line, pos.col);
+    }
+    else if (ts.isIfStatement(node)) {
+        visitIfStatement(t, node);
+    }
+    else if (ts.isForOfStatement(node)) {
+        visitForOfStatement(t, node);
+    }
+    else if (ts.isForStatement(node)) {
+        visitForStatement(t, node);
+    }
+    else if (ts.isWhileStatement(node)) {
+        visitWhileStatement(t, node);
+    }
+    else if (ts.isBlock(node)) {
+        for (const s of node.statements) {
+            visitStatement(t, s);
+        }
+    }
+    else if (ts.isBreakStatement(node)) {
+        t.emitter.writeLine('break', pos.line, pos.col);
+    }
+    else if (ts.isContinueStatement(node)) {
+        t.emitter.writeLine('continue', pos.line, pos.col);
+    }
+    else if (ts.isSwitchStatement(node)) {
+        visitSwitchStatement(t, node);
+    }
+    else if (ts.isForInStatement(node)) {
+        t.addDiagnostic(node, 'error', '`for...in` is not supported; use `for...of` instead');
+    }
+    else {
+        t.addDiagnostic(node, 'error', `Unsupported statement: ${ts.SyntaxKind[node.kind]}`);
+    }
+}
+// ---- Variable Statements ----
+export function visitVariableStatement(t, node) {
+    for (const decl of node.declarationList.declarations) {
+        const pos = t.getLineAndCol(decl);
+        // Check for destructuring
+        if (ts.isArrayBindingPattern(decl.name) ||
+            ts.isObjectBindingPattern(decl.name)) {
+            t.addDiagnostic(decl, 'error', 'Destructuring is not supported in GDScript');
+            continue;
+        }
+        const name = decl.name.getText(t.ctx.sourceFile);
+        // Check for var restriction (const and let are both allowed)
+        const flags = node.declarationList.flags;
+        if (!(flags & (ts.NodeFlags.Const | ts.NodeFlags.Let))) {
+            t.addDiagnostic(node, 'warning', '`var` is restricted; use `let` or `const` instead. Converting to `var`.');
+        }
+        // Type
+        const typeNode = decl.type;
+        const gdType = tsTypeNodeToGdType(typeNode, t.ctx.checker, t.ctx.sourceFile, t.currentClassName);
+        const typeAnnotation = gdType ? `: ${gdType}` : '';
+        // Special case: gd.eval() as initializer
+        if (decl.initializer && isGdEvalCall(decl.initializer)) {
+            const evalLines = processGdEval(t, decl.initializer);
+            if (evalLines && evalLines.length > 0) {
+                // First line becomes the RHS of the var declaration
+                const firstLine = evalLines[0];
+                t.emitter.writeLine(`var ${name}${typeAnnotation} = ${firstLine}`, pos.line, pos.col);
+                // Remaining lines emit at current indent; their embedded \t prefixes
+                // represent relative depth beyond the var line.
+                for (let i = 1; i < evalLines.length; i++) {
+                    t.emitter.writeLine(evalLines[i], pos.line, pos.col);
+                }
+                continue;
+            }
+        }
+        // Initializer
+        const init = decl.initializer
+            ? ` = ${t.emitExpression(decl.initializer)}`
+            : '';
+        t.emitter.writeLine(`var ${name}${typeAnnotation}${init}`, pos.line, pos.col);
+        // If the initializer was a block lambda, emit its body after the declaration line
+        if (decl.initializer && t.isBlockLambda(decl.initializer)) {
+            t.emitLambdaBody(decl.initializer);
+        }
+    }
+}
+// ---- If Statement ----
+export function visitIfStatement(t, node) {
+    const pos = t.getLineAndCol(node);
+    t.emitter.writeLine(`if ${t.emitExpression(node.expression)}:`, pos.line, pos.col);
+    t.emitter.indent();
+    visitStatementBody(t, node.thenStatement);
+    t.emitter.dedent();
+    if (node.elseStatement) {
+        if (ts.isIfStatement(node.elseStatement)) {
+            const elsePos = t.getLineAndCol(node.elseStatement);
+            t.emitter.writeLine(`elif ${t.emitExpression(node.elseStatement.expression)}:`, elsePos.line, elsePos.col);
+            t.emitter.indent();
+            visitStatementBody(t, node.elseStatement.thenStatement);
+            t.emitter.dedent();
+            if (node.elseStatement.elseStatement) {
+                visitElseChain(t, node.elseStatement.elseStatement);
+            }
+        }
+        else {
+            const elsePos = t.getLineAndCol(node.elseStatement);
+            t.emitter.writeLine('else:', elsePos.line, elsePos.col);
+            t.emitter.indent();
+            visitStatementBody(t, node.elseStatement);
+            t.emitter.dedent();
+        }
+    }
+}
+function visitElseChain(t, node) {
+    if (ts.isIfStatement(node)) {
+        const pos = t.getLineAndCol(node);
+        t.emitter.writeLine(`elif ${t.emitExpression(node.expression)}:`, pos.line, pos.col);
+        t.emitter.indent();
+        visitStatementBody(t, node.thenStatement);
+        t.emitter.dedent();
+        if (node.elseStatement) {
+            visitElseChain(t, node.elseStatement);
+        }
+    }
+    else {
+        const pos = t.getLineAndCol(node);
+        t.emitter.writeLine('else:', pos.line, pos.col);
+        t.emitter.indent();
+        visitStatementBody(t, node);
+        t.emitter.dedent();
+    }
+}
+// ---- For Statements ----
+export function visitForOfStatement(t, node) {
+    const pos = t.getLineAndCol(node);
+    const varName = ts.isVariableDeclarationList(node.initializer)
+        ? (node.initializer.declarations[0]?.name.getText(t.ctx.sourceFile) ?? '_')
+        : t.emitExpression(node.initializer);
+    const iterable = t.emitExpression(node.expression);
+    t.emitter.writeLine(`for ${varName} in ${iterable}:`, pos.line, pos.col);
+    t.emitter.indent();
+    visitStatementBody(t, node.statement);
+    t.emitter.dedent();
+}
+export function visitForStatement(t, node) {
+    const pos = t.getLineAndCol(node);
+    if (node.initializer) {
+        if (ts.isVariableDeclarationList(node.initializer)) {
+            visitVariableStatement(t, ts.factory.createVariableStatement(undefined, node.initializer));
+        }
+        else {
+            t.emitter.writeLine(t.emitExpression(node.initializer), pos.line, pos.col);
+        }
+    }
+    const condition = node.condition ? t.emitExpression(node.condition) : 'true';
+    t.emitter.writeLine(`while ${condition}:`, pos.line, pos.col);
+    t.emitter.indent();
+    visitStatementBody(t, node.statement);
+    if (node.incrementor) {
+        const incPos = t.getLineAndCol(node.incrementor);
+        t.emitter.writeLine(t.emitExpression(node.incrementor), incPos.line, incPos.col);
+    }
+    t.emitter.dedent();
+}
+// ---- While Statement ----
+export function visitWhileStatement(t, node) {
+    const pos = t.getLineAndCol(node);
+    t.emitter.writeLine(`while ${t.emitExpression(node.expression)}:`, pos.line, pos.col);
+    t.emitter.indent();
+    visitStatementBody(t, node.statement);
+    t.emitter.dedent();
+}
+// ---- Switch -> Match ----
+export function visitSwitchStatement(t, node) {
+    const pos = t.getLineAndCol(node);
+    t.emitter.writeLine(`match ${t.emitExpression(node.expression)}:`, pos.line, pos.col);
+    t.emitter.indent();
+    for (const clause of node.caseBlock.clauses) {
+        const clausePos = t.getLineAndCol(clause);
+        if (ts.isCaseClause(clause)) {
+            t.emitter.writeLine(`${t.emitExpression(clause.expression)}:`, clausePos.line, clausePos.col);
+            t.emitter.indent();
+            const stmts = clause.statements.filter((s) => !ts.isBreakStatement(s));
+            if (stmts.length === 0) {
+                t.emitter.writeLine('pass', clausePos.line, clausePos.col);
+            }
+            else {
+                for (const stmt of stmts) {
+                    visitStatement(t, stmt);
+                }
+            }
+            t.emitter.dedent();
+        }
+        else {
+            t.emitter.writeLine('_:', clausePos.line, clausePos.col);
+            t.emitter.indent();
+            const stmts = clause.statements.filter((s) => !ts.isBreakStatement(s));
+            if (stmts.length === 0) {
+                t.emitter.writeLine('pass', clausePos.line, clausePos.col);
+            }
+            else {
+                for (const stmt of stmts) {
+                    visitStatement(t, stmt);
+                }
+            }
+            t.emitter.dedent();
+        }
+    }
+    t.emitter.dedent();
+}
+// ---- Statement Body Helper ----
+export function visitStatementBody(t, node) {
+    if (ts.isBlock(node)) {
+        if (node.statements.length === 0) {
+            const pos = t.getLineAndCol(node);
+            t.emitter.writeLine('pass', pos.line, pos.col);
+        }
+        else {
+            for (const stmt of node.statements) {
+                t.emitLeadingComments(stmt);
+                visitStatement(t, stmt);
+            }
+        }
+    }
+    else {
+        visitStatement(t, node);
+    }
+}
+//# sourceMappingURL=statements.js.map