Method lualibFileVisitor

src/lualib-build/plugin.ts:82–152

(file: ts.SourceFile, context: tstl.TransformationContext)

    protected featureDependencies: Map<tstl.LuaLibFeature, Set<tstl.LuaLibFeature>> = new Map();

    protected lualibFileVisitor(file: ts.SourceFile, context: tstl.TransformationContext): tstl.File {
        const featureName = path.basename(file.fileName, ".ts") as tstl.LuaLibFeature;
        if (!(featureName in tstl.LuaLibFeature)) {
            context.diagnostics.push(lualibDiagnostic(`File is not a lualib feature: ${featureName}`, file));
        }

        // Transpile file as normal with tstl
        const fileResult = context.superTransformNode(file)[0] as tstl.File;

        const usedFeatures = new Set<tstl.LuaLibFeature>(context.usedLuaLibFeatures);

        // Get all imports in file
        const importNames = new Set<string>();
        const imports = file.statements.filter(ts.isImportDeclaration);
        for (const { importClause, moduleSpecifier } of imports) {
            if (importClause?.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
                for (const { name } of importClause.namedBindings.elements) {
                    importNames.add(name.text);
                }
            }
            // track lualib imports
            if (ts.isStringLiteral(moduleSpecifier)) {
                const featureName = path.basename(moduleSpecifier.text, ".ts") as tstl.LuaLibFeature;
                if (featureName in tstl.LuaLibFeature) {
                    usedFeatures.add(featureName);
                }
            }
        }

        const filteredStatements = fileResult.statements
            .filter(
                s => !isExportTableDeclaration(s) && !isRequire(s) && !isImport(s, importNames) && !isExportsReturn(s)
            )
            .map(statement => {
                if (isExportAlias(statement)) {
                    const name = statement.left[0];
                    const exportName = statement.right[0].index.value;
                    if (name.text === exportName) return undefined; // Remove "x = x" statements
                    return tstl.createAssignmentStatement(name, tstl.createIdentifier(exportName));
                }
                return statement;
            })
            .filter(statement => statement !== undefined);

        const exportNames = filteredStatements.filter(isExportAssignment).map(s => s.left[0].index.value);
        if (!filteredStatements.every(isExportAssignment)) {
            // If there are local statements, wrap them in a do ... end with exports outside
            const exports = tstl.createVariableDeclarationStatement(exportNames.map(k => tstl.createIdentifier(k)));
            // transform export assignments to local assignments
            const bodyStatements = filteredStatements.map(s =>
                isExportAssignment(s)
                    ? tstl.createAssignmentStatement(tstl.createIdentifier(s.left[0].index.value), s.right[0])
                    : s
            );

            fileResult.statements = [exports, tstl.createDoStatement(bodyStatements)];
        } else {
            // transform export assignments to local variable declarations