@idlizer/arktscgen 2.1.10-arktscgen-4 → 2.1.10-arktscgen-5

package/build/libarkts-copy/src/arkts-api/static/global.ts

@@ -13,95 +13,94 @@
  * limitations under the License.
  */
 
-import { throwError } from "../../utils"
-import { KNativePointer, nullptr } from "@koalaui/interop"
-import { initEs2panda, Es2pandaNativeModule, initGeneratedEs2panda } from "../../Es2pandaNativeModule"
-import { Es2pandaNativeModule as GeneratedEs2pandaNativeModule } from "../../generated/Es2pandaNativeModule"
-import { initInterop, InteropNativeModule } from "../../InteropNativeModule"
-import { Context } from "../peers/Context"
-import { Profiler } from "./profiler"
-import { ArkTsConfig } from "../../generated"
+import { throwError } from '../../utils';
+import { KNativePointer, nullptr } from '@koalaui/interop';
+import { initEs2panda, Es2pandaNativeModule, initGeneratedEs2panda } from '../../Es2pandaNativeModule';
+import { Es2pandaNativeModule as GeneratedEs2pandaNativeModule } from '../../../generated/Es2pandaNativeModule';
+import { initInterop, InteropNativeModule } from '../../InteropNativeModule';
+import { Context } from '../peers/Context';
+import { Profiler } from './profiler';
+import { ArkTsConfig } from '../../../generated';
 import { Config } from '../peers/Config';
 
 export class UpdateTracker {
-    stack: boolean[] = []
+    stack: boolean[] = [];
 
     push() {
-        this.stack.push(false)
+        this.stack.push(false);
     }
 
     update() {
-        this.stack[this.stack.length - 1] = true
+        this.stack[this.stack.length - 1] = true;
     }
 
     check() {
-        return this.stack.pop()
+        return this.stack.pop();
     }
 }
 
 export class global {
-    public static filePath: string = "./plugins/input/main.ets"
+    public static filePath: string = './plugins/input/main.ets';
 
-    public static arktsconfig?: ArkTsConfig
+    public static arktsconfig?: ArkTsConfig;
     public static configObj?: Config;
 
-    private static _config?: KNativePointer
+    private static _config?: KNativePointer;
     public static set config(config: KNativePointer) {
-        global._config = config
+        global._config = config;
         global.configObj = new Config(global._config);
     }
     public static get config(): KNativePointer {
-        return global._config ?? throwError('Global.config not initialized')
+        return global._config ?? throwError('Global.config not initialized');
     }
     public static configIsInitialized(): boolean {
-        return global._config !== undefined && global._config !== nullptr
+        return global._config !== undefined && global._config !== nullptr;
     }
     public static resetConfig(): void {
-        global._config = undefined
+        global._config = undefined;
         global.configObj = undefined;
     }
 
     // Improve: rename to contextPeer
     public static get context(): KNativePointer {
-        return global.compilerContext?.peer ?? throwError('Global.context not initialized')
+        return global.compilerContext?.peer ?? throwError('Global.context not initialized');
     }
 
     // Improve: rename to context when the pointer valued one is eliminated
-    public static compilerContext: Context | undefined
-    public static isContextGenerateAbcForExternalSourceFiles: boolean = false
+    public static compilerContext: Context | undefined;
+    public static isContextGenerateAbcForExternalSourceFiles: boolean = false;
 
-    private static _es2panda: Es2pandaNativeModule | undefined = undefined
+    private static _es2panda: Es2pandaNativeModule | undefined = undefined;
     public static get es2panda(): Es2pandaNativeModule {
         if (this._es2panda === undefined) {
-            this._es2panda = initEs2panda()
+            this._es2panda = initEs2panda();
         }
-        return this._es2panda
+        return this._es2panda;
     }
 
-    private static _generatedEs2panda: GeneratedEs2pandaNativeModule | undefined = undefined
+    private static _generatedEs2panda: GeneratedEs2pandaNativeModule | undefined = undefined;
     public static get generatedEs2panda(): GeneratedEs2pandaNativeModule {
         if (this._generatedEs2panda === undefined) {
-            this._generatedEs2panda = initGeneratedEs2panda()
+            this._generatedEs2panda = initGeneratedEs2panda();
         }
-        return this._generatedEs2panda
+        return this._generatedEs2panda;
     }
 
-    private static _interop: InteropNativeModule | undefined = undefined
+    private static _interop: InteropNativeModule | undefined = undefined;
     public static get interop(): InteropNativeModule {
-        if (this._interop === undefined) this._interop = initInterop()
-        return this._interop
-
+        if (this._interop === undefined) this._interop = initInterop();
+        return this._interop;
     }
 
-    public static profiler = new Profiler()
+    public static profiler = new Profiler();
 
     // Check node type values during node creation
-    public static validatePeerTypes = false
+    public static validatePeerTypes = false;
 
     public static clearContext(): void {
-        global.compilerContext = undefined
+        global.compilerContext = undefined;
     }
 
     // Keep track of update info to optimize performance
-    public static updateTracker: UpdateTracker = new UpdateTracker()
+    public static updateTracker: UpdateTracker = new UpdateTracker();
 }

package/build/libarkts-copy/src/arkts-api/static/globalUtils.ts

@@ -13,10 +13,10 @@
  * limitations under the License.
  */
 
-import { KNativePointer } from "@koalaui/interop";
-import { Context } from "../peers/Context";
-import { global } from "./global";
-import { NodeCache } from "../node-cache"
+import { KNativePointer } from '@koalaui/interop';
+import { Context } from '../peers/Context';
+import { global } from './global';
+import { NodeCache } from '../node-cache';
 
 export function getOrUpdateGlobalContext(peer: KNativePointer): Context {
     if (!global.compilerContext || global.context !== peer) {
@@ -24,4 +24,4 @@ export function getOrUpdateGlobalContext(peer: KNativePointer): Context {
         global.compilerContext = new Context(peer);
     }
     return global.compilerContext;
-}
+}

package/build/libarkts-copy/src/arkts-api/static/profiler.ts

@@ -13,19 +13,19 @@
  * limitations under the License.
  */
 
-import * as fs from "fs"
-import * as path from "path"
-import { Es2pandaContextState } from "../../generated/Es2pandaEnums"
-import { global } from "./global"
+import * as fs from 'fs';
+import * as path from 'path';
+import { Es2pandaContextState } from '../../../generated/Es2pandaEnums';
+import { global } from './global';
 
-const PERFORMANCE_DATA_DIR = "./performance-results/"
+const PERFORMANCE_DATA_DIR = './performance-results/';
 
 interface PluginData {
-    transformTime: number
-    transformTimeDeps: number
-    visitedNodes: number
-    createdNodes: number
-    contextState?: Es2pandaContextState
+    transformTime: number;
+    transformTimeDeps: number;
+    visitedNodes: number;
+    createdNodes: number;
+    contextState?: Es2pandaContextState;
 }
 
 function emptyPluginData(contextState?: Es2pandaContextState): PluginData {
@@ -34,156 +34,172 @@ function emptyPluginData(contextState?: Es2pandaContextState): PluginData {
         transformTimeDeps: 0,
         visitedNodes: 0,
         createdNodes: 0,
-        contextState: contextState
-    }
+        contextState: contextState,
+    };
 }
 
 interface PerformanceData {
-    filePath: string
+    filePath: string;
 
-    visitedNodes: number
-    createdNodes: number
-    proceedTime: number
-    totalTime: number
+    visitedNodes: number;
+    createdNodes: number;
+    proceedTime: number;
+    totalTime: number;
 
-    pluginsByName: Record<string, PluginData>
+    pluginsByName: Record<string, PluginData>;
 }
 
 interface PerformanceDataFile {
-    data: PerformanceData[]
-    summary?: PerformanceData
+    data: PerformanceData[];
+    summary?: PerformanceData;
 }
 
 function parseFile(performanceFile: string): PerformanceDataFile | undefined {
-    if (!fs.existsSync(performanceFile)) return undefined
+    if (!fs.existsSync(performanceFile)) return undefined;
 
-    const data = fs.readFileSync(path.resolve(performanceFile)).toString()
-    if (!data.length) return undefined
-    return JSON.parse(data) as PerformanceDataFile
+    const data = fs.readFileSync(path.resolve(performanceFile)).toString();
+    if (!data.length) return undefined;
+    return JSON.parse(data) as PerformanceDataFile;
 }
 
 export class Profiler implements PerformanceData {
-    filePath: string = ""
-    visitedNodes: number = 0
-    createdNodes: number = 0
-    proceedTime: number = 0
-    totalTime: number = 0
-    pluginsByName: Record<string, PluginData> = {}
+    filePath: string = '';
+    visitedNodes: number = 0;
+    createdNodes: number = 0;
+    proceedTime: number = 0;
+    totalTime: number = 0;
+    pluginsByName: Record<string, PluginData> = {};
 
-    curPlugin: string = ""
-    curContextState?: Es2pandaContextState
+    curPlugin: string = '';
+    curContextState?: Es2pandaContextState;
 
     private getPluginData(pluginName: string, contextState?: Es2pandaContextState): PluginData {
         if (!(pluginName in this.pluginsByName)) {
-            this.pluginsByName[pluginName] = emptyPluginData(contextState)
+            this.pluginsByName[pluginName] = emptyPluginData(contextState);
         }
-        return this.pluginsByName[pluginName]
+        return this.pluginsByName[pluginName];
     }
 
-    disableReport = false
+    disableReport = false;
 
     nodeCreated() {
-        this.createdNodes++
-        if (this.curPlugin) this.getPluginData(this.curPlugin, this.curContextState).createdNodes++
+        this.createdNodes++;
+        if (this.curPlugin) this.getPluginData(this.curPlugin, this.curContextState).createdNodes++;
     }
 
     nodeVisited() {
-        this.visitedNodes++
-        if (this.curPlugin) this.getPluginData(this.curPlugin, this.curContextState).visitedNodes++
+        this.visitedNodes++;
+        if (this.curPlugin) this.getPluginData(this.curPlugin, this.curContextState).visitedNodes++;
     }
 
-    private transformStartTime = 0
-    transformStarted() {
-        this.transformStartTime = Date.now()
+    private transformStartTime = 0;
+    transformStarted(): void {
+        this.transformStartTime = Date.now();
     }
-    private transformDepStartTime = 0
-    transformDepStarted() {
-        this.transformDepStartTime = Date.now()
+    private transformDepStartTime = 0;
+    transformDepStarted(): void {
+        this.transformDepStartTime = Date.now();
     }
 
-    transformEnded(state: Es2pandaContextState, pluginName: string) {
-        const transformEndTime = Date.now()
-        const consumedTime = transformEndTime - this.transformStartTime
-        this.getPluginData(pluginName, state).transformTime += consumedTime
+    transformEnded(state: Es2pandaContextState, pluginName: string): void {
+        const transformEndTime = Date.now();
+        const consumedTime = transformEndTime - this.transformStartTime;
+        this.getPluginData(pluginName, state).transformTime += consumedTime;
     }
 
-    transformDepEnded(state: Es2pandaContextState, pluginName: string) {
-        const transformEndTime = Date.now()
-        const consumedTime = transformEndTime - this.transformDepStartTime
-        this.getPluginData(pluginName, state).transformTimeDeps += consumedTime
+    transformDepEnded(state: Es2pandaContextState, pluginName: string): void {
+        const transformEndTime = Date.now();
+        const consumedTime = transformEndTime - this.transformDepStartTime;
+        this.getPluginData(pluginName, state).transformTimeDeps += consumedTime;
     }
 
     proceededToState(consumedTime: number) {
-        this.proceedTime += consumedTime
+        this.proceedTime += consumedTime;
     }
 
-    private compilationStartTime = 0
+    private compilationStartTime = 0;
     compilationStarted(filePath: string) {
-        this.filePath = filePath
+        this.filePath = filePath;
 
-        this.visitedNodes = 0
-        this.createdNodes = 0
-        this.proceedTime = 0
-        this.totalTime = 0
-        this.pluginsByName = {}
+        this.visitedNodes = 0;
+        this.createdNodes = 0;
+        this.proceedTime = 0;
+        this.totalTime = 0;
+        this.pluginsByName = {};
 
-        this.curPlugin = ""
-        this.compilationStartTime = Date.now()
+        this.curPlugin = '';
+        this.compilationStartTime = Date.now();
     }
 
     compilationEnded() {
-        const consumedTime: number = Date.now() - this.compilationStartTime
-        this.totalTime = consumedTime
+        const consumedTime: number = Date.now() - this.compilationStartTime;
+        this.totalTime = consumedTime;
     }
 
     report() {
         Object.entries(this.pluginsByName).forEach((data, key) => {
-            console.log(data[0], "totalTransformTime =", data[1].transformTime, "ms")
-            console.log(data[0], "totalDepsTransformTime =", data[1].transformTimeDeps, "ms")
-        })
+            console.log(data[0], 'totalTransformTime =', data[1].transformTime, 'ms');
+            console.log(data[0], 'totalDepsTransformTime =', data[1].transformTimeDeps, 'ms');
+        });
     }
 
     reportToFile(withSummary: boolean = false) {
-        if (this.disableReport) return
-        const outDir = path.resolve(global.arktsconfig!.outDir, PERFORMANCE_DATA_DIR)
-        fs.mkdirSync(outDir, { recursive: true })
-        const outFilePath = path.resolve(outDir, path.basename(this.filePath)) + ".json"
-    
-        const data: PerformanceDataFile = { data: [this as PerformanceData] }
+        if (this.disableReport) return;
+        const outDir = path.resolve(global.arktsconfig!.outDir, PERFORMANCE_DATA_DIR);
+        fs.mkdirSync(outDir, { recursive: true });
+        const outFilePath = path.resolve(outDir, path.basename(this.filePath)) + '.json';
+
+        const data: PerformanceDataFile = { data: [this as PerformanceData] };
         if (!fs.existsSync(outFilePath)) {
-            fs.writeFileSync(outFilePath, JSON.stringify(data))
+            fs.writeFileSync(outFilePath, JSON.stringify(data));
         } else {
-            const savedData: PerformanceDataFile | undefined = parseFile(outFilePath) ?? data
-            savedData.data.push(this as PerformanceData)
+            const savedData: PerformanceDataFile | undefined = parseFile(outFilePath) ?? data;
+            savedData.data.push(this as PerformanceData);
 
             if (withSummary) {
                 const summary: PerformanceData = {
                     filePath: this.filePath,
-                    visitedNodes: savedData.data.map(it => it.visitedNodes).reduce((sum, it) => sum + it),
-                    createdNodes: savedData.data.map(it => it.createdNodes).reduce((sum, it) => sum + it),
-                    proceedTime: savedData.data.map(it => it.proceedTime).reduce((sum, it) => sum + it),
-                    totalTime: savedData.data.map(it => it.totalTime).reduce((sum, it) => sum + it),
-                    pluginsByName: {}
-                }
-                const pluginNames = new Set(savedData.data.flatMap(it => Object.keys(it.pluginsByName)))
+                    visitedNodes: savedData.data.map((it) => it.visitedNodes).reduce((sum, it) => sum + it),
+                    createdNodes: savedData.data.map((it) => it.createdNodes).reduce((sum, it) => sum + it),
+                    proceedTime: savedData.data.map((it) => it.proceedTime).reduce((sum, it) => sum + it),
+                    totalTime: savedData.data.map((it) => it.totalTime).reduce((sum, it) => sum + it),
+                    pluginsByName: {},
+                };
+                const pluginNames = new Set(savedData.data.flatMap((it) => Object.keys(it.pluginsByName)));
                 for (const pluginName of pluginNames) {
-                    const sumTransformTime = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].transformTime).reduce((sum, it) => sum+it)
-                    const sumTransformTimeDeps = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].transformTimeDeps).reduce((sum, it) => sum+it)
-                    const sumCreatedNodes = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].createdNodes).reduce((sum, it) => sum+it)
-                    const sumVisitedNodes = savedData.data.map(it => it.pluginsByName).filter(it => !!it[pluginName]).map(it => it[pluginName].visitedNodes).reduce((sum, it) => sum+it)
+                    const sumTransformTime = savedData.data
+                        .map((it) => it.pluginsByName)
+                        .filter((it) => !!it[pluginName])
+                        .map((it) => it[pluginName].transformTime)
+                        .reduce((sum, it) => sum + it);
+                    const sumTransformTimeDeps = savedData.data
+                        .map((it) => it.pluginsByName)
+                        .filter((it) => !!it[pluginName])
+                        .map((it) => it[pluginName].transformTimeDeps)
+                        .reduce((sum, it) => sum + it);
+                    const sumCreatedNodes = savedData.data
+                        .map((it) => it.pluginsByName)
+                        .filter((it) => !!it[pluginName])
+                        .map((it) => it[pluginName].createdNodes)
+                        .reduce((sum, it) => sum + it);
+                    const sumVisitedNodes = savedData.data
+                        .map((it) => it.pluginsByName)
+                        .filter((it) => !!it[pluginName])
+                        .map((it) => it[pluginName].visitedNodes)
+                        .reduce((sum, it) => sum + it);
 
                     summary.pluginsByName[pluginName] = {
                         transformTime: sumTransformTime,
                         transformTimeDeps: sumTransformTimeDeps,
                         createdNodes: sumCreatedNodes,
                         visitedNodes: sumVisitedNodes,
-                    }
+                    };
                 }
 
-                savedData.summary = summary
+                savedData.summary = summary;
             }
 
-            fs.writeFileSync(outFilePath, JSON.stringify(savedData))
+            fs.writeFileSync(outFilePath, JSON.stringify(savedData));
         }
     }
 }

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

@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-import { KInt, KNativePointer, KUInt } from "@koalaui/interop"
+import { KNativePointer, KUInt } from '@koalaui/interop';
 import type {
     ClassDefinition,
     ETSFunctionType,
@@ -25,113 +25,130 @@ import type {
     Program,
     ScriptFunction,
     SourcePosition,
-} from "../../generated"
-import { ExternalSource } from "../peers/ExternalSource"
-import { Es2pandaAstNodeType, Es2pandaModuleFlag } from "../../generated/Es2pandaEnums"
-import { global } from "../static/global"
-import { acceptNativeObjectArrayResult, passNodeArray, unpackNodeArray, unpackNonNullableNode } from "./private"
-import type { AstNode } from "../peers/AstNode"
+} from '../../../generated';
+import { ExternalSource } from '../peers/ExternalSource';
+import { Es2pandaAstNodeType, Es2pandaModuleFlag } from '../../../generated/Es2pandaEnums';
+import { global } from '../static/global';
+import { acceptNativeObjectArrayResult, passNodeArray, unpackNodeArray, unpackNonNullableNode } from './private';
+import type { AstNode } from '../peers/AstNode';
 
 export function extension_ETSModuleGetNamespaceFlag(this: ETSModule): Es2pandaModuleFlag {
-    return (this.isETSScript ? Es2pandaModuleFlag.MODULE_FLAG_ETSSCRIPT : 0)
-        + (this.isNamespace ? Es2pandaModuleFlag.MODULE_FLAG_NAMESPACE : 0)
-        + (this.isNamespaceChainLastNode ? Es2pandaModuleFlag.MODULE_FLAG_NAMESPACE_CHAIN_LAST_NODE : 0)
+    return (
+        (this.isETSScript ? Es2pandaModuleFlag.MODULE_FLAG_ETSSCRIPT : 0) +
+        (this.isNamespace ? Es2pandaModuleFlag.MODULE_FLAG_NAMESPACE : 0) +
+        (this.isNamespaceChainLastNode ? Es2pandaModuleFlag.MODULE_FLAG_NAMESPACE_CHAIN_LAST_NODE : 0)
+    );
 }
 
 // this is a workaround for overloads not included in children list
 export function extension_MethodDefinitionSetChildrenParentPtr(this: MethodDefinition) {
-    global.es2panda._AstNodeSetChildrenParentPtr(global.context, this.peer)
-    const overloads = this.overloads
+    global.es2panda._AstNodeSetChildrenParentPtr(global.context, this.peer);
+    const overloads = this.overloads;
     for (const overload of overloads) {
-        overload.setBaseOverloadMethod(this)
-        overload.parent = this // overloads are not listed as children in native
+        overload.setBaseOverloadMethod(this);
+        overload.parent = this; // overloads are not listed as children in native
     }
 }
 
 export function extension_MethodDefinitionOnUpdate(this: MethodDefinition, original: MethodDefinition): void {
-    this.setChildrenParentPtr()
-    global.es2panda._AstNodeOnUpdate(global.context, this.peer, original.peer)
-    const originalBase = original.baseOverloadMethod
+    this.setChildrenParentPtr();
+    global.es2panda._AstNodeOnUpdate(global.context, this.peer, original.peer);
+    const originalBase = original.baseOverloadMethod;
     if (originalBase) {
-        this.setBaseOverloadMethod(originalBase)
+        this.setBaseOverloadMethod(originalBase);
     }
 }
 
 // Improve: generate checker related stuff
 export function extension_ScriptFunctionGetSignaturePointer(this: ScriptFunction): KNativePointer {
-    return global.es2panda._Checker_ScriptFunctionSignature(global.context, this.peer)
+    return global.es2panda._Checker_ScriptFunctionSignature(global.context, this.peer);
 }
 
-export function extension_ScriptFunctionSetSignaturePointer(this: ScriptFunction, signaturePointer: KNativePointer): void {
-    global.es2panda._Checker_ScriptFunctionSetSignature(global.context, this.peer, signaturePointer)
+export function extension_ScriptFunctionSetSignaturePointer(
+    this: ScriptFunction,
+    signaturePointer: KNativePointer
+): void {
+    global.es2panda._Checker_ScriptFunctionSetSignature(global.context, this.peer, signaturePointer);
 }
 
 // Improve: weird API
 export function extension_ScriptFunctionGetParamsCasted(this: ScriptFunction): readonly ETSParameterExpression[] {
-    return unpackNodeArray<ETSParameterExpression>(global.generatedEs2panda._ScriptFunctionParams(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION)
+    return unpackNodeArray<ETSParameterExpression>(
+        global.generatedEs2panda._ScriptFunctionParams(global.context, this.peer),
+        Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION
+    );
 }
 
 // Improve: perhaps "preferredReturnType" stuff can be removed later if "signature" is always enough
 export function extension_ScriptFunctionGetPreferredReturnTypePointer(this: ScriptFunction): KNativePointer {
-    return global.es2panda._Checker_ScriptFunctionGetPreferredReturnType(global.context, this.peer)
+    return global.es2panda._Checker_ScriptFunctionGetPreferredReturnType(global.context, this.peer);
 }
 
-export function extension_ScriptFunctionSetPreferredReturnTypePointer(this: ScriptFunction, typePointer: KNativePointer): void {
-    global.es2panda._Checker_ScriptFunctionSetPreferredReturnType(global.context, this.peer, typePointer)
+export function extension_ScriptFunctionSetPreferredReturnTypePointer(
+    this: ScriptFunction,
+    typePointer: KNativePointer
+): void {
+    global.es2panda._Checker_ScriptFunctionSetPreferredReturnType(global.context, this.peer, typePointer);
 }
 
 // Improve: generate checker related stuff
 export function extension_ExpressionGetPreferredTypePointer(this: Expression): KNativePointer {
-    return global.es2panda._Checker_ExpressionGetPreferredType(global.context, this.peer)
+    return global.es2panda._Checker_ExpressionGetPreferredType(global.context, this.peer);
 }
 
 export function extension_ExpressionSetPreferredTypePointer(this: Expression, typePointer: KNativePointer): void {
-    global.es2panda._Checker_ExpressionSetPreferredType(global.context, this.peer, typePointer)
+    global.es2panda._Checker_ExpressionSetPreferredType(global.context, this.peer, typePointer);
 }
 
 // Improve: weird API
 export function extension_ProgramGetAstCasted(this: Program): ETSModule {
-    return unpackNonNullableNode<ETSModule>(global.generatedEs2panda._ProgramAst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE)
+    return unpackNonNullableNode<ETSModule>(
+        global.generatedEs2panda._ProgramAst(global.context, this.peer),
+        Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE
+    );
 }
 
 // Improve: generate methods with string[] args or return type
 export function extension_ProgramGetExternalSources(this: Program): ExternalSource[] {
     return acceptNativeObjectArrayResult<ExternalSource>(
         global.es2panda._ProgramExternalSources(global.context, this.peer),
-        ExternalSource.instantiate,
-    )
+        ExternalSource.instantiate
+    );
 }
 
 // Improve: SourcePositionLine is global in idl
 export function extension_SourcePositionGetLine(this: SourcePosition): KUInt {
-    return global.generatedEs2panda._SourcePositionLine(global.context, this.peer)
+    return global.generatedEs2panda._SourcePositionLine(global.context, this.peer);
 }
 
 // Improve: SourcePositionCol is not described in idl
 export function extension_SourcePositionGetCol(this: SourcePosition): KUInt {
-    return global.es2panda._SourcePositionCol(global.context, this.peer)
+    return global.es2panda._SourcePositionCol(global.context, this.peer);
 }
 
 // Improve: SourcePositionIndex is global in idl
 export function extension_SourcePositionGetIndex(this: SourcePosition): KUInt {
-    return global.generatedEs2panda._SourcePositionIndex(global.context, this.peer)
+    return global.generatedEs2panda._SourcePositionIndex(global.context, this.peer);
 }
 
 export function extension_SourcePositionToString(this: SourcePosition): string {
-    return `:${this.getLine() + 1}:${this.getCol()}`
+    return `:${this.getLine() + 1}:${this.getCol()}`;
 }
 
 // Improve: weird API
 export function extension_NumberLiteralValue(this: NumberLiteral): number {
-    return +this.dumpSrc()
+    return +this.dumpSrc();
 }
 
 // Improve: weird API
 export function extension_ClassDefinitionSetBody(this: ClassDefinition, body: readonly AstNode[]): void {
-    global.es2panda._ClassDefinitionSetBody(global.context, this.peer, passNodeArray(body), body.length)
+    global.es2panda._ClassDefinitionSetBody(global.context, this.peer, passNodeArray(body), body.length);
 }
 
 // Improve: weird API
 export function extension_ETSFunctionTypeGetParamsCasted(this: ETSFunctionType): readonly ETSParameterExpression[] {
-    return unpackNodeArray<ETSParameterExpression>(global.generatedEs2panda._ETSFunctionTypeParamsConst(global.context, this.peer), Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION)
+    return unpackNodeArray<ETSParameterExpression>(
+        global.generatedEs2panda._ETSFunctionTypeParamsConst(global.context, this.peer),
+        Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION
+    );
 }