@idlizer/arktscgen 2.1.7 → 2.1.9-arktscgen-4

package/build/libarkts-copy/src/arkts-api/peers/Context.ts

@@ -14,10 +14,11 @@
  */
 
 import { ArktsObject } from "./ArktsObject"
-import { Program } from "./Program"
+import { Program } from "../../generated"
 import { global } from "../static/global"
-import { passString } from "../utilities/private"
-import { KNativePointer } from "@koalaui/interop"
+import { passString, passStringArray } from "../utilities/private"
+import { KNativePointer, nullptr } from "@koalaui/interop"
+import { Config } from "./Config"
 
 export class Context extends ArktsObject {
     constructor(peer: KNativePointer) {
@@ -39,7 +40,73 @@ export class Context extends ArktsObject {
         )
     }
 
+    static createFromFile(filePath: string, configPath: string, stdlibPath: string, outputPath: string): Context | undefined {
+        const config = Config.create([
+            "",
+            "--arktsconfig",
+            configPath,
+            '--extension',
+            'ets',
+            '--stdlib',
+            stdlibPath,
+            filePath,
+            '--output',
+            outputPath,
+        ])
+        return new Context(
+            global.es2panda._CreateContextFromFile(
+                config.peer,
+                passString(filePath)
+            )
+        )
+    }
+
+    static createCacheFromFile(filePath: string, config: Config, globalContext: GlobalContext, isExternal: boolean) {
+        return new Context(
+            global.es2panda._CreateCacheContextFromFile(
+                config.peer,
+                passString(filePath),
+                globalContext.peer,
+                isExternal
+            )
+        )
+    }
+
+
+    destroy() {
+        if (this.peer != nullptr) {
+            global.es2panda._DestroyContext(this.peer)
+            this.peer = nullptr
+        }
+    }
+
     get program(): Program {
         return new Program(global.es2panda._ContextProgram(this.peer));
     }
-}
+}
+
+export class GlobalContext extends ArktsObject {
+    static create(
+        config: Config, externalFileList: string[]
+    ): GlobalContext {
+        return new GlobalContext(
+            global.es2panda._CreateGlobalContext(
+                config.peer,
+                passStringArray(externalFileList),
+                externalFileList.length,
+                false
+            )
+        )
+    }
+
+    constructor(peer: KNativePointer) {
+        super(peer)
+    }
+
+    destroy() {
+        if (this.peer != nullptr) {
+            global.es2panda._DestroyGlobalContext(this.peer)
+            this.peer = nullptr
+        }
+    }
+}

package/build/libarkts-copy/src/arkts-api/peers/{Program.ts → ExternalSource.ts}

@@ -13,31 +13,11 @@
  * limitations under the License.
  */
 
-import { ArktsObject } from "./ArktsObject"
 import { global } from "../static/global"
 import { acceptNativeObjectArrayResult, unpackString } from "../utilities/private"
 import { KNativePointer, nullptr } from "@koalaui/interop"
-import { ETSModule } from "../../generated"
-
-export class Program extends ArktsObject {
-    constructor(peer: KNativePointer) {
-        super(peer)
-    }
-
-    get astNode(): ETSModule {
-        let program = global.es2panda._ProgramAst(global.context, this.peer)
-        if (program == nullptr) throw new Error(`astNode() cannt get AST`)
-        return new ETSModule(program)
-    }
-
-    get externalSources(): ExternalSource[] {
-        return acceptNativeObjectArrayResult<ExternalSource>(
-            global.es2panda._ProgramExternalSources(global.context, this.peer),
-            (instance: KNativePointer) => new ExternalSource(instance)
-        )
-    }
-
-}
+import { Program } from "../../generated"
+import { ArktsObject } from "./ArktsObject"
 
 export class ExternalSource extends ArktsObject {
     constructor(peer: KNativePointer) {

package/build/libarkts-copy/src/arkts-api/peers/Options.ts

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 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 { KNativePointer } from "@koalaui/interop"
+import { ArktsObject } from "./ArktsObject"
+import { global } from "../static/global"
+import { Config } from "./Config"
+import { ArkTsConfig } from "../../generated"
+
+export class Options extends ArktsObject {
+    constructor(peer: KNativePointer) {
+        super(peer)
+    }
+
+    static createOptions(config: Config) {
+        return new Options(global.es2panda._ConfigGetOptions(config.peer))
+    }
+
+    getArkTsConfig(): ArkTsConfig {
+        return new ArkTsConfig(global.es2panda._OptionsArkTsConfig(global.context, this.peer))
+    }
+}

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

@@ -14,15 +14,34 @@
  */
 
 import { Es2pandaContextState } from "../generated/Es2pandaEnums"
-import { ExternalSource, Program } from "./peers/Program"
+import { Program } from "../generated"
+import { ExternalSource } from "./peers/ExternalSource"
+import { programGetExternalSources } from "./node-utilities/Program"
+import { KNativePointer } from "@koalaui/interop"
+import { global } from "./static/global"
 
 export interface CompilationOptions {
     readonly isMainProgram: boolean,
-    readonly name: string,
     readonly stage: Es2pandaContextState,
+    readonly restart: boolean,
 }
 
-export type ProgramTransformer = (program: Program, compilationOptions: CompilationOptions) => void
+export interface PluginContext {
+    setParameter<V>(name: string, value: V): void
+    parameter<V>(name: string) : V | undefined
+
+}
+export class PluginContextImpl implements PluginContext {
+    map = new Map<String, Object|undefined>()
+    parameter<V>(name: string): V|undefined {
+        return this.map.get(name) as (V|undefined)
+    }
+    setParameter<V>(name: string, value: V) {
+        this.map.set(name, value as Object)
+    }
+}
+
+export type ProgramTransformer = (program: Program, compilationOptions: CompilationOptions, context: PluginContext) => void
 
 export function defaultFilter(name: string) {
     if (name.startsWith("std.")) return false
@@ -30,17 +49,12 @@ export function defaultFilter(name: string) {
     return true
 }
 
-export interface ProgramWithName {
-    program: Program,
-    name: string
-}
-
-export function listPrograms(program: Program, filter: (name: string) => boolean = defaultFilter): ProgramWithName[] {
+export function listPrograms(program: Program, filter: (name: string) => boolean = defaultFilter, context: KNativePointer = global.context): Program[] {
     return [
-        { program, name: "" },
-        ...program.externalSources.flatMap((it: ExternalSource) => {
+        program,
+        ...programGetExternalSources(program, context).flatMap((it: ExternalSource) => {
             if (filter(it.getName())) {
-                return it.programs.map(program => ({ program, name: it.getName() } as ProgramWithName))
+                return it.programs
             }
             return []
         })

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

@@ -20,12 +20,12 @@ import { Es2pandaNativeModule as GeneratedEs2pandaNativeModule } from "../../gen
 import { initInterop, InteropNativeModule } from "../../InteropNativeModule"
 import { Context } from "../peers/Context"
 import { Profiler } from "./profiler"
-import { Program } from "../peers/Program"
+import { ArkTsConfig } from "../../generated"
 
 export class global {
     public static filePath: string = "./plugins/input/main.ets"
-    public static packageName: string = ""
-    public static filePathFromPackageRoot: string = global.filePath
+
+    public static arktsconfig?: ArkTsConfig
 
     private static _config?: KNativePointer
     public static set config(config: KNativePointer) {
@@ -37,10 +37,13 @@ export class global {
     public static configIsInitialized(): boolean {
         return global._config !== undefined && global._config !== nullptr
     }
+    public static resetConfig(): void {
+        global._config = undefined
+    }
 
     // TODO: 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')
     }
 
     // TODO: rename to context when the pointer valued one is eliminated

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

@@ -13,28 +13,185 @@
  * limitations under the License.
  */
 
-export class Profiler {
-    totalTime = 0
-    transformTime = 0
-    proceedTime = 0
-    restartTime = 0
-    visitedNodes = 0
-    createdNodes = 0
+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/"
+
+interface PluginData {
+    transformTime: number
+    transformTimeDeps: number
+    visitedNodes: number
+    createdNodes: number
+    contextState?: Es2pandaContextState
+}
+
+function emptyPluginData(contextState?: Es2pandaContextState): PluginData {
+    return {
+        transformTime: 0,
+        transformTimeDeps: 0,
+        visitedNodes: 0,
+        createdNodes: 0,
+        contextState: contextState
+    }
+}
+
+interface PerformanceData {
+    filePath: string
+
+    visitedNodes: number
+    createdNodes: number
+    restartTime: number
+    proceedTime: number
+    totalTime: number
+
+    pluginsByName: Record<string, PluginData>
+}
+
+interface PerformanceDataFile {
+    data: PerformanceData[]
+    summary?: PerformanceData
+}
+
+function parseFile(performanceFile: string): PerformanceDataFile | 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
+}
+
+export class Profiler implements PerformanceData {
+    filePath: string = ""
+    visitedNodes: number = 0
+    createdNodes: number = 0
+    restartTime: number = 0
+    proceedTime: number = 0
+    totalTime: number = 0
+    pluginsByName: Record<string, PluginData> = {}
+
+    curPlugin: string = ""
+    curContextState?: Es2pandaContextState
+
+    private getPluginData(pluginName: string, contextState?: Es2pandaContextState): PluginData {
+        if (!(pluginName in this.pluginsByName)) {
+            this.pluginsByName[pluginName] = emptyPluginData(contextState)
+        }
+        return this.pluginsByName[pluginName]
+    }
+
+    disableReport = false
+
+    nodeCreated() {
+        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++
+    }
+
+    private transformStartTime = 0
+    transformStarted() {
+        this.transformStartTime = Date.now()
+    }
+    private transformDepStartTime = 0
+    transformDepStarted() {
+        this.transformDepStartTime = Date.now()
+    }
+
+    transformEnded(state: Es2pandaContextState, pluginName: string) {
+        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
+    }
+
+    restarted(consumedTime: number) {
+        this.restartTime += consumedTime
+    }
+
+    proceededToState(consumedTime: number) {
+        this.proceedTime += consumedTime
+    }
+
+    private compilationStartTime = 0
+    compilationStarted(filePath: string) {
+        this.filePath = filePath
+
+        this.visitedNodes = 0
+        this.createdNodes = 0
+        this.restartTime = 0
+        this.proceedTime = 0
+        this.totalTime = 0
+        this.pluginsByName = {}
+
+        this.curPlugin = ""
+        this.compilationStartTime = Date.now()
+    }
+
+    compilationEnded() {
+        const consumedTime: number = Date.now() - this.compilationStartTime
+        this.totalTime = consumedTime
+    }
 
     report() {
-        console.log(
-            "total compiler:",
-            this.totalTime,
-            " proceeds:",
-            this.proceedTime,
-            " restarts",
-            this.restartTime,
-            " transforms:",
-            this.transformTime,
-            " visited:",
-            this.visitedNodes,
-            " created:",
-            this.createdNodes
-        )
-    }
-}
+        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")
+        })
+    }
+
+    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 (!fs.existsSync(outFilePath)) {
+            fs.writeFileSync(outFilePath, JSON.stringify(data))
+        } else {
+            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),
+                    restartTime: savedData.data.map(it => it.restartTime).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)
+
+                    summary.pluginsByName[pluginName] = {
+                        transformTime: sumTransformTime,
+                        transformTimeDeps: sumTransformTimeDeps,
+                        createdNodes: sumCreatedNodes,
+                        visitedNodes: sumVisitedNodes,
+                    }
+                }
+
+                savedData.summary = summary
+            }
+
+            fs.writeFileSync(outFilePath, JSON.stringify(savedData))
+        }
+    }
+}

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

@@ -121,13 +121,9 @@ export function unpackString(peer: KNativePointer): string {
 
 // TODO: use direct string arguments instead.
 export function passString(str: string | undefined): string {
-    if (str === undefined) {
-        return ""
-    }
-    return withString(str, (it: string) => it)
+    return str ?? ""
 }
 
-
 // TODO: use direct string arguments instead.
 export function passStringArray(strings: readonly string[]): string[] {
     return withStringArray(strings, (it: string[]) => it)
@@ -147,9 +143,7 @@ export function updateNodeByNode<T extends ArktsObject>(node: T, original: T): T
     if (original.peer === nullptr) {
         throwError('update called on NULLPTR')
     }
-    if (original instanceof AstNode) {
-        global.generatedEs2panda._AstNodeSetOriginalNode(global.context, node.peer, original.originalPeer)
-    }
+    original.onUpdate(node)
     global.generatedEs2panda._AstNodeSetParent(global.context, node.peer, global.generatedEs2panda._AstNodeParent(global.context, original.peer))
     global.es2panda._AstNodeUpdateChildren(global.context, node.peer)
     return node
@@ -158,3 +152,33 @@ export function updateNodeByNode<T extends ArktsObject>(node: T, original: T): T
 export function nodeType(node: AstNode): Es2pandaAstNodeType {
     return global.generatedEs2panda._AstNodeTypeConst(global.context, passNode(node))
 }
+
+/**
+ * @deprecated
+ */
+export function compose<T extends ArktsObject, ARGS extends any[]>(
+    create: (...args: ARGS) => T,
+    update: (node: T, original: T) => T = updateNodeByNode
+): (node: T, ...args: ARGS) => T {
+    return (node: T, ...args: ARGS) => update(create(...args), node);
+}
+
+export function updateThenAttach<T extends ArktsObject, ARGS extends any[]>(
+    update: (original: T, ...args: ARGS) => T,
+    ...attachFuncs: ((node: T, original: T) => T)[]
+): (node: T, ...args: ARGS) => T {
+    return (node: T, ...args: ARGS) => {
+        let _node: T = update(node, ...args);
+        attachFuncs.forEach((attach) => {
+            _node = attach(_node, node);
+        });
+        return _node;
+    };
+}
+
+export function attachModifiers<T extends ArktsObject>(node: T, original: T): T {
+    if (node instanceof AstNode && original instanceof AstNode) {
+        node.modifiers = original.modifiers;
+    }
+    return node;
+}

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

@@ -14,16 +14,16 @@
  */
 
 import { global } from "../static/global"
-import { isNumber, throwError } from "../../utils"
+import { isNumber, throwError, withWarning } from "../../utils"
 import { KNativePointer, nullptr } from "@koalaui/interop"
 import { passNode, passNodeArray, unpackNodeArray, unpackNonNullableNode } from "./private"
 import { Es2pandaContextState, Es2pandaModifierFlags } from "../../generated/Es2pandaEnums"
 import type { AstNode } from "../peers/AstNode"
+import { isSameNativeObject } from "../peers/ArktsObject"
 import {
     type AnnotationUsage,
     ClassDefinition,
     ClassProperty,
-    ETSImportDeclaration,
     ETSModule,
     isClassDefinition,
     isFunctionDeclaration,
@@ -35,13 +35,19 @@ import {
 import { Config } from "../peers/Config"
 import { Context } from "../peers/Context"
 import { NodeCache } from "../node-cache"
+import { listPrograms } from "../plugins"
 
 export function createETSModuleFromContext(): ETSModule {
     let program = global.es2panda._ContextProgram(global.context)
     if (program == nullptr) {
         throw new Error(`Program is null for context ${global.context.toString(16)}`)
     }
-    return new ETSModule(global.es2panda._ProgramAst(global.context, program))
+    const ast = global.es2panda._ProgramAst(global.context, program)
+    if (ast == nullptr) {
+        throw new Error(`AST is null for program ${program.toString(16)}`)
+
+    }
+    return new ETSModule(ast)
 }
 
 export function createETSModuleFromSource(
@@ -59,10 +65,18 @@ export function createETSModuleFromSource(
     return new ETSModule(global.es2panda._ProgramAst(global.context, program))
 }
 
+export function metaDatabase(fileName: string): string {
+    if (fileName.endsWith(".meta.json")) throw new Error(`Must pass source, not database: ${fileName}`)
+    return `${fileName}.meta.json`
+}
+
 export function updateETSModuleByStatements(
     node: ETSModule,
     statements: readonly AstNode[],
 ): ETSModule {
+    if (isSameNativeObject(statements, node.statements)) {
+        return node
+    }
     global.generatedEs2panda._BlockStatementSetStatements(global.context, node.peer, passNodeArray(statements), statements.length)
     return node
 }
@@ -83,7 +97,7 @@ export function proceedToState(state: Es2pandaContextState): void {
     const before = Date.now()
     global.es2panda._ProceedToState(global.context, state)
     const after = Date.now()
-    global.profiler.proceedTime += after-before
+    global.profiler.proceededToState(after-before)
     NodeCache.clear()
     checkErrors()
 }
@@ -102,6 +116,19 @@ export function rebindSubtree(node: AstNode): void {
     checkErrors()
 }
 
+export function recheckContext(context: KNativePointer): void {
+    global.es2panda._AstNodeRecheck(
+        context,
+        global.es2panda._ProgramAst(
+            context,
+            global.es2panda._ContextProgram(
+                context
+            )
+        )
+    )
+    checkErrors()
+}
+
 export function getDecl(node: AstNode): AstNode | undefined {
     if (isMemberExpression(node)) {
         return getDecl(node.property!)
@@ -139,14 +166,6 @@ export function getFileName(): string {
     return global.filePath
 }
 
-export function getPackageName(): string {
-    return global.packageName
-}
-
-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
@@ -197,3 +216,26 @@ export function nameIfETSModule(node: AstNode): string {
 export function asString(node: AstNode|undefined): string {
     return `${node?.constructor.name} ${node ? nameIfIdentifier(node) : undefined}`
 }
+
+const defaultPandaSdk = "../../../incremental/tools/panda/node_modules/@panda/sdk"
+
+
+export function findStdlib(): string {
+    const sdk = process.env.PANDA_SDK_PATH ?? withWarning(
+        defaultPandaSdk,
+        `PANDA_SDK_PATH not set, assuming ${defaultPandaSdk}`
+    )
+    return `${sdk}/ets/stdlib`
+}
+
+export function collectDependencies(files: string[], configPath: string): string[] {
+    const result = new Set<string>()
+    for (let file of files) {
+        const context = Context.createFromFile(file, configPath, findStdlib(), "/tmp/foo.abc")!
+        global.compilerContext = context
+        proceedToState(Es2pandaContextState.ES2PANDA_STATE_PARSED)
+        listPrograms(context.program).forEach(it => result.add(it.absoluteName))
+        context.destroy()
+    }
+    return Array.from(result)
+}