@idlizer/arktscgen 2.1.2

package/build/libarkts-copy/src/arkts-api/utilities/public.ts

@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { global } from "../static/global"
+import { isNumber, throwError } from "../../utils"
+import { nullptr, withStringResult } from "@koalaui/interop"
+import { passNode, passNodeArray, unpackNodeArray, unpackNonNullableNode } from "./private"
+import { Es2pandaContextState, Es2pandaModifierFlags } from "../../generated/Es2pandaEnums"
+import type { AstNode } from "../peers/AstNode"
+import {
+    type AnnotationUsage,
+    ClassDefinition,
+    ETSModule,
+    isClassDefinition,
+    isMemberExpression,
+    isScriptFunction,
+    isFunctionDeclaration
+} from "../../generated"
+import { Config } from "../peers/Config"
+import { Context } from "../peers/Context"
+
+export function createETSModulefromContext(): ETSModule {
+    return new ETSModule(global.es2panda._ProgramAst(global.context, global.es2panda._ContextProgram(global.context)))
+}
+
+export function createETSModuleFromSource(
+    source: string,
+    state: Es2pandaContextState = Es2pandaContextState.ES2PANDA_STATE_PARSED,
+): ETSModule {
+    if (!global.configIsInitialized()) {
+        global.config = Config.createDefault().peer
+    }
+    global.compilerContext = Context.createFromString(source)
+    proceedToState(state)
+    return new ETSModule(global.es2panda._ProgramAst(global.context, global.es2panda._ContextProgram(global.context)))
+}
+
+export function updateETSModuleByStatements(
+    node: ETSModule,
+    statements: readonly AstNode[],
+): ETSModule {
+    global.generatedEs2panda._BlockStatementSetStatements(global.context, node.peer, passNodeArray(statements), statements.length)
+    return node
+}
+
+export function proceedToState(state: Es2pandaContextState): void {
+    if (state <= global.es2panda._ContextState(global.context)) {
+        return
+    }
+    global.es2panda._ProceedToState(global.context, state)
+    if (global.es2panda._ContextState(global.context) === Es2pandaContextState.ES2PANDA_STATE_ERROR) {
+        console.log()
+        global.es2panda._DestroyConfig(global.config)
+        console.log()
+        process.exit(1)
+    }
+}
+
+export function startChecker(): boolean {
+    return global.es2panda._CheckerStartChecker(global.context)
+}
+
+export function recheckSubtree(node: AstNode): void {
+    global.es2panda._AstNodeRecheck(global.context, node.peer)
+}
+
+export function rebindSubtree(node: AstNode): void {
+    global.es2panda._AstNodeRebind(global.context, node.peer)
+}
+
+export function getDecl(node: AstNode): AstNode | undefined {
+    if (isMemberExpression(node)) {
+        return getDecl(node.property)
+    }
+    const decl = global.es2panda._DeclarationFromIdentifier(global.context, passNode(node))
+    if (decl === nullptr) {
+        return undefined
+    }
+    return unpackNonNullableNode(decl)
+}
+
+export function getAnnotations(node: AstNode): readonly AnnotationUsage[] {
+    if (!isFunctionDeclaration(node) && !isScriptFunction(node) && !isClassDefinition(node)) {
+        throwError('for now annotations allowed only for: functionDeclaration, scriptFunction, classDefinition')
+    }
+    return unpackNodeArray(global.es2panda._AnnotationAllowedAnnotations(global.context, node.peer, nullptr))
+}
+
+export function getOriginalNode(node: AstNode): AstNode {
+    if (node === undefined) {
+        // TODO: fix this
+        throwError('there is no arkts pair of ts node (unable to getOriginalNode)')
+    }
+    if (node.originalPeer === nullptr) {
+        return node
+    }
+    return unpackNonNullableNode(node.originalPeer)
+}
+
+export function getFileName(): string {
+    return global.filePath
+}
+
+export function getFilePathFromPackageRoot(): string {
+    return global.filePathFromPackageRoot
+}
+
+// TODO: It seems like Definition overrides AstNode  modifiers
+// with it's own modifiers which is completely unrelated set of flags.
+// Use this function if you need
+// the language level modifiers: public, declare, export, etc.
+export function classDefinitionFlags(node: ClassDefinition): Es2pandaModifierFlags {
+    return global.generatedEs2panda._AstNodeModifiers(global.context, node.peer)
+}
+
+export function modifiersToString(modifiers: Es2pandaModifierFlags): string {
+     return Object.values(Es2pandaModifierFlags)
+            .filter(isNumber)
+            .map(it => {
+                console.log(it.valueOf(), Es2pandaModifierFlags[it], modifiers.valueOf() & it)
+                return ((modifiers.valueOf() & it) === it) ? Es2pandaModifierFlags[it] : ""
+            }).join(" ")
+}

package/build/libarkts-copy/src/arkts-api/visitor.ts

@@ -0,0 +1,297 @@
+/*
+ * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { factory } from "./factory/nodeFactory"
+import { Es2pandaVariableDeclaratorFlag } from "../generated/Es2pandaEnums"
+import { AstNode } from "./peers/AstNode"
+import {
+    isArrowFunctionExpression,
+    isBlockStatement,
+    isCallExpression,
+    isClassDeclaration,
+    isClassDefinition,
+    isConditionalExpression,
+    isETSImportDeclaration,
+    isETSStructDeclaration,
+    isExpressionStatement,
+    isFunctionDeclaration,
+    isIfStatement,
+    isMemberExpression,
+    isReturnStatement,
+    isScriptFunction,
+    isTSAsExpression,
+    isTSInterfaceBody,
+    isTSInterfaceDeclaration,
+    isVariableDeclaration,
+    isVariableDeclarator,
+    isETSModule,
+    isMethodDefinition,
+} from "../generated"
+import { classDefinitionFlags, updateETSModuleByStatements } from "./utilities/public"
+
+type Visitor = (node: AstNode) => AstNode
+
+export interface DoubleNode {
+    originNode: AstNode;
+    translatedNode: AstNode;
+}
+
+export class StructInfo {
+    stateVariables: Set<DoubleNode> = new Set();
+}
+
+export class GlobalInfo {
+    private _structCollection: Set<string>;
+    private static instance: GlobalInfo;
+    private _structMap: Map<string, StructInfo>;
+
+    private constructor() {
+        this._structCollection = new Set();
+        this._structMap = new Map();
+    }
+
+    public static getInfoInstance(): GlobalInfo {
+        if (!this.instance) {
+            this.instance = new GlobalInfo();
+        }
+        return this.instance;
+    }
+
+    public add(str: string): void {
+        this._structCollection.add(str);
+    }
+
+    public getStructCollection(): Set<string> {
+        return this._structCollection;
+    }
+
+    public getStructInfo(structName: string): StructInfo {
+        const structInfo = this._structMap.get(structName);
+        if (!structInfo) {
+            return new StructInfo();
+        }
+        return structInfo;
+    }
+
+    public setStructInfo(structName: string, info: StructInfo): void {
+        this._structMap.set(structName, info);
+    }
+}
+
+// TODO: rethink (remove as)
+function nodeVisitor<T extends AstNode | undefined>(node: T, visitor: Visitor): T {
+    if (node === undefined) {
+        return node
+    }
+    return visitor(node) as T
+}
+
+// TODO: rethink (remove as)
+function nodesVisitor<T extends AstNode, TIn extends readonly T[] | undefined>(nodes: TIn, visitor: Visitor): T[] | TIn {
+    if (nodes === undefined) {
+        return nodes
+    }
+    return nodes.map(node => visitor(node) as T)
+}
+
+export function visitEachChild(
+    node: AstNode,
+    visitor: Visitor
+): AstNode {
+    if (isETSModule(node)) {
+        return updateETSModuleByStatements(
+            node,
+            nodesVisitor(node.statements, visitor)
+        )
+    }
+    if (isCallExpression(node)) {
+        return factory.updateCallExpression(
+            node,
+            nodeVisitor(node.callee, visitor),
+            nodesVisitor(node.arguments, visitor),
+            nodeVisitor(node.typeParams, visitor),
+            node.isOptional,
+            node.hasTrailingComma,
+            nodeVisitor(node.trailingBlock, visitor)
+        )
+    }
+    if (isFunctionDeclaration(node)) {
+        return factory.updateFunctionDeclaration(
+            node,
+            nodeVisitor(node.function, visitor),
+            node.annotations,
+            node.isAnonymous,
+        )
+    }
+    if (isBlockStatement(node)) {
+        return factory.updateBlockStatement(
+            node,
+            nodesVisitor(node.statements, visitor),
+        )
+    }
+    if (isExpressionStatement(node)) {
+        return factory.updateExpressionStatement(
+            node,
+            nodeVisitor(node.expression, visitor)
+        )
+    }
+    if (isETSStructDeclaration(node)) {
+        return factory.updateETSStructDeclaration(
+            node,
+            nodeVisitor(node.definition, visitor)
+        )
+    }
+    if (isClassDeclaration(node)) {
+        return factory.updateClassDeclaration(
+            node,
+            nodeVisitor(node.definition, visitor)
+        )
+    }
+    if (isClassDefinition(node)) {
+        // TODO: fix
+        return factory.updateClassDefinition(
+            node,
+            node.ident,
+            node.typeParams,
+            node.superTypeParams,
+            node.implements,
+            undefined,
+            node.super,
+            nodesVisitor(node.body, visitor),
+            node.modifiers,
+            classDefinitionFlags(node)
+        )
+    }
+    if (isMethodDefinition(node)) {
+        return factory.updateMethodDefinition(
+            node,
+            node.kind,
+            node.id,
+            factory.createFunctionExpression(
+                node.id,
+                nodeVisitor(node.function, visitor)
+            ),
+            node.modifiers,
+            node.isComputed
+        )
+    }
+    if (isScriptFunction(node)) {
+        return factory.updateScriptFunction(
+            node,
+            nodeVisitor(node.body, visitor),
+            node.typeParams,
+            node.params,
+            node.returnTypeAnnotation,
+            node.hasReceiver,
+            node.flags,
+            node.modifiers,
+            node.id,
+            node.annotations,
+        )
+    }
+    if (isETSImportDeclaration(node)) {
+        return factory.updateETSImportDeclaration(
+            node,
+            factory.createImportSource(
+                node.source,
+                node.resolvedSource,
+                node.hasDecl
+            ),
+            nodesVisitor(node.specifiers, visitor),
+            +node.isTypeKind,
+        )
+    }
+    if (isMemberExpression(node)) {
+        return factory.updateMemberExpression(
+            node,
+            nodeVisitor(node.object, visitor),
+            nodeVisitor(node.property, visitor),
+            node.kind,
+            node.isComputed,
+            node.isOptional
+        )
+    }
+    if (isTSInterfaceDeclaration(node)) {
+        return factory.updateInterfaceDeclaration(
+            node,
+            nodesVisitor(node.extends, visitor),
+            nodeVisitor(node.id, visitor),
+            nodeVisitor(node.typeParams, visitor),
+            nodeVisitor(node.body, visitor),
+            node.isStatic,
+            // TODO: how do I get it?
+            true
+        )
+    }
+    if (isTSInterfaceBody(node)) {
+        return factory.updateTSInterfaceBody(
+            node,
+            nodesVisitor(node.body, visitor)
+        )
+    }
+    if (isIfStatement(node)) {
+        return factory.updateIfStatement(
+            node,
+            nodeVisitor(node.test, visitor),
+            nodeVisitor(node.consequent, visitor),
+            nodeVisitor(node.alternate, visitor),
+        )
+    }
+    if (isConditionalExpression(node)) {
+        return factory.updateConditionalExpression(
+            node,
+            nodeVisitor(node.test, visitor),
+            nodeVisitor(node.consequent, visitor),
+            nodeVisitor(node.alternate, visitor),
+        )
+    }
+    if (isVariableDeclaration(node)) {
+        return factory.updateVariableDeclaration(
+            node,
+            node.kind,
+            nodesVisitor(node.declarators, visitor),
+        )
+    }
+    if (isVariableDeclarator(node)) {
+        return factory.updateVariableDeclarator(
+            node,
+            Es2pandaVariableDeclaratorFlag.VARIABLE_DECLARATOR_FLAG_UNKNOWN,
+            nodeVisitor(node.id, visitor),
+            nodeVisitor(node.init, visitor),
+        )
+    }
+    if (isArrowFunctionExpression(node)) {
+        return factory.updateArrowFunctionExpression(
+            node,
+            nodeVisitor(node.function, visitor),
+        )
+    }
+    if (isReturnStatement(node)) {
+        return factory.updateReturnStatement(
+            node,
+            nodeVisitor(node.argument, visitor)
+        )
+    }
+    if (isTSAsExpression(node)) {
+        return factory.updateTSAsExpression(
+            node,
+            nodeVisitor(node.expr, visitor),
+            nodeVisitor(node.typeAnnotation, visitor),
+            node.isConst
+        )
+    }
+    // TODO
+    return node
+}

package/build/libarkts-copy/src/es2panda.ts

@@ -0,0 +1,277 @@
+/*
+ * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as fs from "node:fs"
+import * as path from "node:path"
+import { global } from "./arkts-api/static/global"
+import { Command } from "commander"
+import { isNumber, throwError, withWarning, filterSource } from "./utils"
+import { Es2pandaContextState } from "./generated/Es2pandaEnums"
+import { AstNode, Config, Context, createETSModulefromContext, ETSModule, proceedToState } from "./arkts-api"
+
+function parseCommandLineArgs() {
+    const commander = new Command()
+        .option('--file, <char>', 'Path to file to be compiled')
+        .option('--arktsconfig, <char>', 'Path to arkts configuration file')
+        .option('--ets-module', 'Do nothing, legacy compatibility')
+        .option('--output, <char>', 'The name of result file')
+        .option('--dump-plugin-ast', 'Dump ast before and after each plugin')
+        .option('--restart-stages', 'Restart the compiler to proceed to next stage')
+        .option('--generate-decl', 'Generate declaration files')
+        .option('--decl-arktsconfig, <char>', 'Path to arkts configutation file for the binary compilation')
+        .parse(process.argv)
+        .opts()
+
+    const restOptions = commander.args
+
+    const filePath = path.resolve(commander.file)
+    const configPath = path.resolve(commander.arktsconfig)
+    const outputPath = path.resolve(commander.output)
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`File path doesn't exist: ${filePath}`)
+    }
+    if (!fs.existsSync(configPath)) {
+        throw new Error(`Arktsconfig path doesn't exist: ${configPath}`)
+    }
+
+    const dumpAst = commander.dumpPluginAst ?? false
+    const restartStages = commander.restartStages ?? false
+    const generateDecl = commander.generateDecl ?? false
+    const dConfigPath = path.resolve(commander.declArktsconfig ?? commander.arktsconfig)
+
+    return { filePath, configPath, outputPath, dumpAst, restartStages, generateDecl, dConfigPath }
+}
+
+function insertPlugin(plugin: (ast: AstNode) => void, state: Es2pandaContextState, dumpAst: boolean): AstNode {
+    proceedToState(state)
+    const script = createETSModulefromContext()
+    if (script === undefined) {
+        throwError(`Failed to receive ast from es2panda`)
+    }
+
+    if (dumpAst) {
+        console.log(`BEFORE ${stateName(state)}:`)
+        console.log(filterSource(script.dumpSrc()))
+    }
+
+    const transform = plugin
+    transform?.(script)
+
+    if (dumpAst) {
+        console.log(`AFTER ${stateName(state)}:`)
+        console.log(filterSource(script.dumpSrc()))
+    }
+
+    setAllParents(script)
+    return script
+}
+
+function restartCompiler() {
+    console.log("restarting")
+    const ast = createETSModulefromContext()
+    const srcText = filterSource(ast.dumpSrc())
+    global.es2panda._DestroyContext(global.context)
+    global.compilerContext = Context.createFromString(srcText)
+}
+
+function restartCompilerWithConfig(configPath: string, filePath: string, stdlib: string, outputPath: string) {
+    console.log("restarting with another config")
+    const srcText = filterSource(createETSModulefromContext().dumpSrc())
+    global.es2panda._DestroyContext(global.context)
+    global.es2panda._DestroyConfig(global.config)
+    global.config = Config.create([
+        '_',
+        '--arktsconfig',
+        configPath,
+        filePath,
+        '--extension',
+        'ets',
+        '--stdlib',
+        stdlib,
+        '--output',
+        outputPath
+    ]).peer
+    global.compilerContext = Context.createFromString(srcText)
+}
+
+const defaultPandaSdk = "../../../incremental/tools/panda/node_modules/@panda/sdk"
+function invokeWithPlugins(
+    configPath: string,
+    baseUrl: string,
+    filePath: string,
+    outputPath: string,
+    pluginsByState: Map<Es2pandaContextState, ((ast: AstNode) => void)[]>,
+    dumpAst: boolean,
+    restart: boolean,
+    generateDecl: boolean,
+    dConfigPath: string,
+): void {
+    const source = fs.readFileSync(filePath).toString()
+    const sdk = process.env.PANDA_SDK_PATH ?? withWarning(
+        defaultPandaSdk,
+        `PANDA_SDK_PATH not set, assuming ${defaultPandaSdk}`
+    )
+    const stdlib = `${sdk}/ets/stdlib`
+
+    global.filePath = filePath
+    global.filePathFromPackageRoot = path.relative(path.join(path.dirname(configPath), baseUrl), filePath)
+    global.config = Config.create([
+        '_',
+        '--arktsconfig',
+        configPath,
+        filePath,
+        '--extension',
+        'ets',
+        '--stdlib',
+        stdlib,
+        '--output',
+        outputPath
+    ]).peer
+    fs.mkdirSync(path.dirname(outputPath), {recursive: true})
+    global.compilerContext = Context.createFromString(source)
+
+    console.log("PLUGINS: ", pluginsByState.size, pluginsByState)
+
+    if (pluginsByState.size == 0) {
+        proceedToState(Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED)
+        return
+    }
+
+    pluginsByState.get(Es2pandaContextState.ES2PANDA_STATE_PARSED)?.forEach(plugin => {
+        insertPlugin(plugin, Es2pandaContextState.ES2PANDA_STATE_PARSED, dumpAst)
+        if (restart) {
+            restartCompiler()
+        }
+    })
+
+    pluginsByState.get(Es2pandaContextState.ES2PANDA_STATE_CHECKED)?.forEach(plugin => {
+        insertPlugin(plugin, Es2pandaContextState.ES2PANDA_STATE_CHECKED, dumpAst)
+        // TODO: Normally we need just to proceed to a given state,
+        //  but the compiler crashes now, so we restart
+        if (restart) {
+            restartCompiler()
+        }
+    })
+
+    if (configPath !== dConfigPath) {
+        proceedToState(Es2pandaContextState.ES2PANDA_STATE_PARSED)
+        restartCompilerWithConfig(dConfigPath, filePath, stdlib, outputPath)
+    }
+
+    if (generateDecl) {
+        proceedToState(Es2pandaContextState.ES2PANDA_STATE_PARSED)
+        generateDeclFromCurrentContext(filePath)
+    }
+
+    proceedToState(Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED)
+}
+
+function generateDeclFromCurrentContext(filePath: string) {
+    const ext = path.extname(filePath)
+    const dirs = path.dirname(filePath).split(path.sep)
+    const last = dirs.lastIndexOf("ets")
+    if (last == -1) {
+        throw `Do not apply --generate-decl for files not matching "**/ets/**" file path: ${filePath}`
+    }
+
+    let declFile = ""
+    if (last !== -1) { // temporary workaround (ets dir -> dets dir)
+        const declDir = path.join('/', ...dirs.map((it, index) => index == last ? "dets" : it))
+        fs.mkdirSync(declDir, { recursive: true })
+        declFile = path.join(declDir, path.basename(filePath))
+    } else { // extension change (.ets -> .d.ets)
+        declFile = path.join(path.dirname(filePath), `${path.basename(filePath, ext)}.d${ext}`)
+    }
+    console.log(`Emiting declaration file to`, declFile)
+
+    const exports = [...fs.readFileSync(filePath).toString().matchAll(/export .* from .*(\n|$)/g)]
+
+    let out = [
+        filterSource(global.compilerContext.program.astNode.dumpSrc()),
+        ...exports.map((it) => it[0])
+    ].join('\n')
+
+    // TODO: exports are lost on visiting
+    const exportAstNodes = ["class", "abstract class", "interface", "@interface", "type", "enum", "final class"]
+    exportAstNodes.forEach((astNodeText) => {
+            out = out.replaceAll(`\n${astNodeText}`, `\nexport ${astNodeText}`)
+        }
+    )
+
+    // TODO: global functions are not exported
+    fs.writeFileSync(declFile,
+        out
+        .replaceAll("\nexport abstract class ETSGLOBAL", "\nabstract class ETSGLOBAL")
+    )
+}
+
+function setAllParents(ast: AstNode) {
+    global.es2panda._AstNodeUpdateAll(global.context, ast.peer)
+}
+
+function loadPlugin(configDir: string, jsonPlugin: any) {
+    const pluginPath = jsonPlugin.transform ?? throwError(`arktsconfig plugins objects should specify transform`)
+    /** TODO: read and pass plugin options */
+    const plugin = (pluginPath.startsWith(".") || pluginPath.startsWith("/")) ?
+        path.resolve(configDir, pluginPath) : pluginPath
+
+    const pluginFunction: (config?: any) => any = require(plugin).default(jsonPlugin)
+    return pluginFunction
+}
+
+function selectPlugins(configDir: string, plugins: any[], stage: string): ((arg: AstNode) => AstNode)[] | undefined {
+    const selected = plugins
+        .filter(it => (it.stage == stage))
+        .map(it => loadPlugin(configDir, it))
+    if (selected.length == 0) {
+        return undefined
+    }
+    return selected
+}
+
+function stateName(value: Es2pandaContextState): string {
+    return Es2pandaContextState[value].substring("ES2PANDA_STATE_".length)
+}
+
+function readAndSortPlugins(configDir: string, plugins: any[]) {
+    const pluginsByState = new Map<Es2pandaContextState, ((ast: AstNode) => void)[]>()
+
+    Object.values(Es2pandaContextState)
+        .filter(isNumber)
+        .forEach(it => {
+            const selected = selectPlugins(configDir, plugins, stateName(it).toLowerCase())
+            if (selected) pluginsByState.set(
+                it,
+                selected
+            )
+        })
+
+    return pluginsByState
+}
+
+export function main() {
+    const { filePath, configPath, outputPath, dumpAst, restartStages, generateDecl, dConfigPath } = parseCommandLineArgs()
+    const arktsconfig = JSON.parse(fs.readFileSync(configPath).toString())
+    const configDir = path.dirname(configPath)
+    const compilerOptions = arktsconfig.compilerOptions ?? throwError(`arktsconfig should specify compilerOptions`)
+    const baseUrl = compilerOptions.baseUrl
+    const plugins = compilerOptions.plugins ?? []
+
+    const pluginsByState = readAndSortPlugins(configDir, plugins)
+
+    invokeWithPlugins(configPath, baseUrl, filePath, outputPath, pluginsByState, dumpAst, restartStages, generateDecl, dConfigPath)
+}
+
+main()