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

package/build/libarkts-copy/src/arkts-api/wrapper-compat.ts

@@ -15,18 +15,18 @@
 
 // koala-wrapper compatibility helpers
 
-import { KNativePointer } from "@koalaui/interop"
-import { ETSModule } from "../generated"
-import { createETSModuleFromContext } from "./utilities/public"
-import { global } from "./static/global"
+import { KNativePointer } from '@koalaui/interop';
+import { ETSModule } from '../../generated';
+import { createETSModuleFromContext } from './utilities/public';
+import { global } from './static/global';
 
 export class EtsScript {
     public static fromContext(): ETSModule {
-        return createETSModuleFromContext()
+        return createETSModuleFromContext();
     }
 }
 
 export function destroyConfig(config: KNativePointer): void {
-    global.es2panda._DestroyConfig(config)
-    global.resetConfig()
-}
+    global.es2panda._DestroyConfig(config);
+    global.resetConfig();
+}

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

@@ -13,28 +13,25 @@
  * limitations under the License.
  */
 
-import * as fs from "fs"
-import * as path from "path"
+import * as fs from 'fs';
+import * as path from 'path';
 
 function reportErrorAndExit(message: string): never {
-    console.error(message)
-    process.exit(1)
+    console.error(message);
+    process.exit(1);
 }
 
 export function checkSDK() {
-    const panda = process.env.PANDA_SDK_PATH
-    if (!panda)
-        reportErrorAndExit(`Variable PANDA_SDK_PATH is not set, please fix`)
+    const panda = process.env.PANDA_SDK_PATH;
+    if (!panda) reportErrorAndExit(`Variable PANDA_SDK_PATH is not set, please fix`);
     if (!fs.existsSync(path.join(panda, 'package.json')))
-        reportErrorAndExit(`Variable PANDA_SDK_PATH not points to SDK`)
-    const packageJson = JSON.parse(fs.readFileSync(path.join(panda, 'package.json')).toString())
-    const version = packageJson.version as string
-    if (!version)
-        reportErrorAndExit(`version is unknown`)
-    const packageJsonOur = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json')).toString())
-    const expectedVersion = packageJsonOur.config.panda_sdk_version
-    if (expectedVersion && expectedVersion != "next" && version != expectedVersion)
-        console.log(`WARNING: Panda SDK version "${version}" doesn't match expected "${expectedVersion}"`)
-    else
-        console.log(`Using Panda ${version}`)
+        reportErrorAndExit(`Variable PANDA_SDK_PATH not points to SDK`);
+    const packageJson = JSON.parse(fs.readFileSync(path.join(panda, 'package.json')).toString());
+    const version = packageJson.version as string;
+    if (!version) reportErrorAndExit(`version is unknown`);
+    const packageJsonOur = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json')).toString());
+    const expectedVersion = packageJsonOur.config.panda_sdk_version;
+    if (expectedVersion && expectedVersion !== 'next' && version !== expectedVersion)
+        console.log(`WARNING: Panda SDK version "${version}" doesn't match expected "${expectedVersion}"`);
+    else console.log(`Using Panda ${version}`);
 }

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

@@ -13,35 +13,35 @@
  * limitations under the License.
  */
 
-export * from "./checkSdk"
-export * from "./utils"
-export * from "./reexport-for-generated"
-export * from "./generated/Es2pandaEnums"
-export * from "./generated"
+export * from './checkSdk';
+export * from './utils';
+export * from './reexport-for-generated';
+export * from '../generated/Es2pandaEnums';
+export * from '../generated';
 
-export * from "./arkts-api/utilities/performance"
-export * from "./arkts-api/utilities/private"
-export * from "./arkts-api/utilities/public"
-export * from "./arkts-api/factory/nodeFactory"
-export * from "./arkts-api/visitor"
-export * from "./arkts-api/AbstractVisitor"
-export * from "./arkts-api/plugins"
-export * from "./arkts-api/ImportStorage"
-export * from "./arkts-api/ProgramProvider"
-export * from "./arkts-api/node-utilities/Program"
-export * from "./arkts-api/node-utilities/ArkTsConfig"
+export * from './arkts-api/utilities/performance';
+export * from './arkts-api/utilities/private';
+export * from './arkts-api/utilities/public';
+export * from './arkts-api/factory/nodeFactory';
+export * from './arkts-api/visitor';
+export * from './arkts-api/AbstractVisitor';
+export * from './arkts-api/plugins';
+export * from './arkts-api/ImportStorage';
+export * from './arkts-api/ProgramProvider';
+export * from './arkts-api/node-utilities/Program';
+export * from './arkts-api/node-utilities/ArkTsConfig';
 
-export * from "./arkts-api/peers/AstNode"
-export * from "./arkts-api/peers/Config"
-export * from "./arkts-api/peers/Context"
-export { GlobalContext } from "./arkts-api/peers/Context"
-export * from "./arkts-api/peers/ExternalSource"
-export * from "./arkts-api/peers/ImportPathManager"
-export * from "./arkts-api/peers/Options"
-export * from "./arkts-api/peers/DiagnosticKind"
-export { global as arktsGlobal } from "./arkts-api/static/global"
-export * from "./arkts-api/static/globalUtils"
-export * as arkts from "./arkts-api"
+export * from './arkts-api/peers/AstNode';
+export * from './arkts-api/peers/Config';
+export * from './arkts-api/peers/Context';
+export { GlobalContext } from './arkts-api/peers/Context';
+export * from './arkts-api/peers/ExternalSource';
+export * from './arkts-api/peers/ImportPathManager';
+export * from './arkts-api/peers/Options';
+export { global as arktsGlobal } from './arkts-api/static/global';
+export * from './arkts-api/static/globalUtils';
+export * as arkts from './arkts-api';
 
-export * from "./plugin-utils"
-export * from "./tracer"
+export * from './plugin-utils';
+export * from './tracer';
+export * from './memo-node-cache';

package/build/libarkts-copy/src/memo-node-cache.ts

@@ -0,0 +1,143 @@
+/*
+ * 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 { AstNode, Es2pandaAstNodeType, factory, unpackString } from "./arkts-api";
+import { global } from "./arkts-api/static/global";
+
+// Improve: this should actually belong to plugin contexts, not to libarkts
+
+export interface AstNodeCacheValue {
+    peer: KNativePointer;
+    type: Es2pandaAstNodeType;
+    metadata?: AstNodeCacheValueMetadata;
+}
+
+export interface AstNodeCacheValueMetadata {
+    callName?: string;
+    hasReceiver?: boolean;
+    isSetter?: boolean;
+    isGetter?: boolean;
+    forbidTypeRewrite?: boolean;
+    isWithinTypeParams?: boolean;
+    hasMemoSkip?: boolean;
+    hasMemoIntrinsic?: boolean;
+    hasMemoEntry?: boolean;
+}
+
+export class MemoNodeCache {
+    private _isCollected: boolean = false;
+    private cacheMap: Map<KNativePointer, AstNodeCacheValue>;
+    private static instance: MemoNodeCache;
+    static disableMemoNodeCache = false;
+
+    private constructor() {
+        this.cacheMap = new Map();
+    }
+
+    static getInstance(): MemoNodeCache {
+        if (!this.instance) {
+            this.instance = new MemoNodeCache();
+        }
+        if (this.disableMemoNodeCache) {
+            return this.instance
+        }
+
+        // Please provide the another way to force cache update on when node updates
+        wrapFuncWithNodeCache(this.instance, "updateArrowFunctionExpression")
+        wrapFuncWithNodeCache(this.instance, "updateBreakStatement")
+        wrapFuncWithNodeCache(this.instance, "updateCallExpression")
+        wrapFuncWithNodeCache(this.instance, "updateClassProperty")
+        wrapFuncWithNodeCache(this.instance, "updateETSFunctionType")
+        wrapFuncWithNodeCache(this.instance, "updateETSParameterExpression")
+        wrapFuncWithNodeCache(this.instance, "updateETSUnionType")
+        wrapFuncWithNodeCache(this.instance, "updateIdentifier")
+        wrapFuncWithNodeCache(this.instance, "updateMethodDefinition")
+        wrapFuncWithNodeCache(this.instance, "updateProperty")
+        wrapFuncWithNodeCache(this.instance, "updateReturnStatement")
+        wrapFuncWithNodeCache(this.instance, "updateScriptFunction")
+        wrapFuncWithNodeCache(this.instance, "updateTSTypeAliasDeclaration")
+        wrapFuncWithNodeCache(this.instance, "updateVariableDeclarator")
+
+        return this.instance;
+    }
+
+    collect(node: AstNode, metadata?: AstNodeCacheValueMetadata): void {
+        if (MemoNodeCache.disableMemoNodeCache) {
+            return
+        }
+        const peer = node.peer;
+        const type = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer);
+        let currMetadata: AstNodeCacheValueMetadata | undefined = metadata ?? {};
+        if (this.cacheMap.has(peer)) {
+            const oldMetadata = this.cacheMap.get(peer)!.metadata ?? {};
+            currMetadata = { ...oldMetadata, ...currMetadata };
+        }
+        currMetadata = Object.keys(currMetadata).length === 0 ? undefined : currMetadata;
+        this.cacheMap.set(peer, { peer, type, metadata: currMetadata });
+        this._isCollected = true;
+    }
+
+    refresh(original: AstNode, node: AstNode): void {
+        let metadata: AstNodeCacheValueMetadata | undefined;
+        if (this.has(original)) {
+            metadata = this.get(original)?.metadata;
+            this.cacheMap.delete(original.peer);
+        }
+        this.collect(node, metadata);
+    }
+
+    isCollected(): boolean {
+        return this._isCollected;
+    }
+
+    has(node: AstNode): boolean {
+        return this.cacheMap.has(node.peer);
+    }
+
+    get(node: AstNode): AstNodeCacheValue | undefined {
+        return this.cacheMap.get(node.peer);
+    }
+
+    clear(): void {
+        this.cacheMap.clear();
+        this._isCollected = false;
+    }
+
+    visualize(): void {
+        Array.from(this.cacheMap.values()).forEach(({ peer, type, metadata }) => {
+            const src = global.generatedEs2panda._AstNodeDumpEtsSrcConst(global.context, peer)
+            console.log(
+                `[NODE CACHE] ptr ${peer}, type: ${type}, metadata: ${JSON.stringify(metadata)}, node: `,
+                unpackString(src)
+            );
+        });
+    }
+}
+
+function wrapFuncWithNodeCache(cache: MemoNodeCache, funcName: keyof typeof factory) {
+    if ((funcName+"__orig") in factory) return;
+
+    let orig = factory[funcName] as any;
+    let wrapped = function (this: any, original: AstNode, ...args: any[]) {
+        let newNode = orig.call(this, original, ...args);
+        if (cache.has(original)) {
+            cache.refresh(original, newNode);
+        }
+        return newNode
+    };
+    (factory as any)[funcName] = wrapped as any;
+    (factory as any)[funcName+"__orig"] = orig as any;
+}

package/build/libarkts-copy/src/plugin-utils.ts

@@ -23,102 +23,121 @@ import {
     ProgramProvider,
     CompilationOptions,
     dumpProgramSrcFormatted,
-} from "./arkts-api"
-import { Tracer } from "./tracer"
+} from './arkts-api';
+import { Tracer } from './tracer';
 
 export interface RunTransformerHooks {
-    onProgramTransformStart?(options: CompilationOptions, program: Program): void
-    onProgramTransformEnd?(options: CompilationOptions, program: Program): void
+    onProgramTransformStart?(options: CompilationOptions, program: Program): void;
+    onProgramTransformEnd?(options: CompilationOptions, program: Program): void;
 }
 
 class ASTCache {
-    processedPrograms = new Set<string>()
-    constructor() { }
+    processedPrograms = new Set<string>();
+    constructor() {}
     find(program: Program): boolean {
-        return this.processedPrograms.has(program.absoluteName)
+        return this.processedPrograms.has(program.absoluteName);
     }
     update(program: Program) {
-        this.processedPrograms.add(program.absoluteName)
+        this.processedPrograms.add(program.absoluteName);
     }
 }
 
 export class DumpingHooks implements RunTransformerHooks {
-    constructor(private state: Es2pandaContextState, private pluginName: string, private dumpAst: boolean = false) {
+    constructor(
+        private state: Es2pandaContextState,
+        private pluginName: string,
+        private dumpAst: boolean = false
+    ) {
         if (process.env.KOALA_DUMP_PLUGIN_AST) {
-            this.dumpAst = true
+            this.dumpAst = true;
         }
     }
     onProgramTransformStart(options: CompilationOptions, program: Program) {
-        if (this.dumpAst) {
-            console.log(`BEFORE ${this.pluginName}:`)
-            dumpProgramSrcFormatted(program, true)
+        if (this.dumpAst && !program.absoluteName.includes("absolute-sdk-patched")) {
+            console.log(`BEFORE ${this.pluginName}:`);
+            dumpProgramSrcFormatted(program, true);
         }
-        if (!options.isProgramForCodegeneration) arktsGlobal.profiler.transformDepStarted()
+        if (!options.isProgramForCodegeneration) arktsGlobal.profiler.transformDepStarted();
     }
     onProgramTransformEnd(options: CompilationOptions, program: Program) {
-        if (!options.isProgramForCodegeneration) arktsGlobal.profiler.transformDepEnded(this.state, this.pluginName)
-        if (this.dumpAst) {
-            console.log(`AFTER ${this.pluginName}:`)
-            dumpProgramSrcFormatted(program, true)
+        if (!options.isProgramForCodegeneration) arktsGlobal.profiler.transformDepEnded(this.state, this.pluginName);
+        if (this.dumpAst && !program.absoluteName.includes("absolute-sdk-patched")) {
+            console.log(`AFTER ${this.pluginName}:`);
+            dumpProgramSrcFormatted(program, true);
         }
     }
 }
 
+export function runTransformerOnProgram(
+    program: Program,
+    options: CompilationOptions,
+    transform: ProgramTransformer | undefined,
+    pluginContext: PluginContext,
+    hooks: RunTransformerHooks = {},
+    stableDeps: boolean = false,
+) {
+    arktsGlobal.filePath = program.absoluteName;
 
-export function runTransformerOnProgram(program: Program, options: CompilationOptions, transform: ProgramTransformer | undefined, pluginContext: PluginContext, hooks: RunTransformerHooks = {}) {
-    arktsGlobal.filePath = program.absoluteName
-
-    Tracer.startProgramTracing(program)
+    Tracer.startProgramTracing(program);
 
     // Perform some additional actions before the transformation start
-    hooks.onProgramTransformStart?.(options, program)
+    hooks.onProgramTransformStart?.(options, program);
 
-    // Save currently existing imports in the program
-    const importStorage = new ImportStorage(program, options.state == Es2pandaContextState.ES2PANDA_STATE_PARSED)
+    if (stableDeps) {
+        // Run the plugin itself
+        transform?.(program, options, pluginContext);
+    } else {
+        // Save currently existing imports in the program
+        const importStorage = new ImportStorage(program, options.state === Es2pandaContextState.ES2PANDA_STATE_PARSED);
 
-    // Run the plugin itself
-    transform?.(program, options, pluginContext)
+        // Run the plugin itself
+        transform?.(program, options, pluginContext);
 
-    // Update internal import information based on import modification by plugin
-    importStorage.update()
+        // Update internal import information based on import modification by plugin
+        importStorage.update();
+    }
 
     // Perform some additional actions after the transformation end
-    hooks.onProgramTransformEnd?.(options, program)
+    hooks.onProgramTransformEnd?.(options, program);
 
-    Tracer.stopProgramTracing()
+    Tracer.stopProgramTracing();
 }
 
-export function runTransformer(prog: Program, state: Es2pandaContextState, transform: ProgramTransformer | undefined, pluginContext: PluginContext, hooks: RunTransformerHooks = {}) {
+export function runTransformer(
+    prog: Program,
+    state: Es2pandaContextState,
+    transform: ProgramTransformer | undefined,
+    pluginContext: PluginContext,
+    hooks: RunTransformerHooks = {},
+    stableDeps: boolean = false,
+) {
     // Program provider used to provide programs to transformer dynamically relative to inserted imports
-    const provider = new ProgramProvider(prog)
+    const provider = new ProgramProvider(prog, stableDeps);
 
     // The first program provided by program provider is the main program
-    let currentProgram = provider.next()
-    let isMainProgram = true
+    let currentProgram = provider.next();
+    let isMainProgram = true;
 
     while (currentProgram) {
         // Options passed to plugin and hooks
         const options: CompilationOptions = {
             isProgramForCodegeneration: isProgramForCodegeneration(currentProgram, isMainProgram),
             state,
-        }
+        };
 
-        runTransformerOnProgram(currentProgram, options, transform, pluginContext, hooks)
+        runTransformerOnProgram(currentProgram, options, transform, pluginContext, hooks, stableDeps);
 
         // The first program is always the main program
-        isMainProgram = false
+        isMainProgram = false;
 
         // Proceed to the next program
-        currentProgram = provider.next()
+        currentProgram = provider.next();
     }
 }
 
-function isProgramForCodegeneration(
-    program: Program,
-    isMainProgram: boolean,
-): boolean {
+function isProgramForCodegeneration(program: Program, isMainProgram: boolean): boolean {
     if (!arktsGlobal.isContextGenerateAbcForExternalSourceFiles) {
-        return isMainProgram
+        return isMainProgram;
     }
-    return program.isGenAbcForExternal
+    return program.isGenAbcForExternal;
 }

package/build/libarkts-copy/src/reexport-for-generated.ts

@@ -12,21 +12,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-export { KNativePointer } from "@koalaui/interop"
-export { AstNode } from "./arkts-api/peers/AstNode"
-export { ArktsObject, isSameNativeObject } from "./arkts-api/peers/ArktsObject"
-export { NodeCache } from "./arkts-api/node-cache"
+export { KNativePointer } from '@koalaui/interop';
+export { AstNode } from './arkts-api/peers/AstNode';
+export { Config } from './arkts-api/peers/Config';
+export { Context, GlobalContext } from './arkts-api/peers/Context';
+export { ArktsObject, isSameNativeObject } from './arkts-api/peers/ArktsObject';
+export { NodeCache } from './arkts-api/node-cache';
 export {
     passNode,
     unpackNonNullableNode,
     unpackNodeArray,
     passNodeArray,
+    passStringArray,
     unpackNode,
     unpackString,
     assertValidPeer,
-    updateNodeByNode
-} from "./arkts-api/utilities/private"
-export { nodeByType } from "./arkts-api/class-by-peer"
-export { global } from "./arkts-api/static/global"
-export { Es2pandaMemberExpressionKind } from "./generated/Es2pandaEnums"
-export * from "./arkts-api/utilities/extensions"
+    updateNodeByNode,
+} from './arkts-api/utilities/private';
+export { nodeByType } from './arkts-api/class-by-peer';
+export { global } from './arkts-api/static/global';
+export { Es2pandaMemberExpressionKind } from '../generated/Es2pandaEnums';
+export * from './arkts-api/utilities/extensions';