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

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

@@ -13,6 +13,8 @@
  * limitations under the License.
  */
 
+import * as fs from "node:fs";
+import * as path from "node:path";
 import {
     Es2pandaContextState,
     PluginContext,
@@ -22,49 +24,24 @@ import {
     Program,
     ProgramProvider,
     CompilationOptions,
-    dumpProgramSrcFormatted,
+    PluginContextImpl,
 } from './arkts-api';
 import { Tracer } from './tracer';
+import { global } from "./arkts-api/static/global";
 
 export interface RunTransformerHooks {
     onProgramTransformStart?(options: CompilationOptions, program: Program): void;
     onProgramTransformEnd?(options: CompilationOptions, program: Program): void;
 }
 
-class ASTCache {
-    processedPrograms = new Set<string>();
-    constructor() {}
-    find(program: Program): boolean {
-        return this.processedPrograms.has(program.absoluteName);
-    }
-    update(program: Program) {
-        this.processedPrograms.add(program.absoluteName);
-    }
-}
-
-export class DumpingHooks implements RunTransformerHooks {
-    constructor(
-        private state: Es2pandaContextState,
-        private pluginName: string,
-        private dumpAst: boolean = false
-    ) {
-        if (process.env.KOALA_DUMP_PLUGIN_AST) {
-            this.dumpAst = true;
-        }
+export class ProfilerHooks implements RunTransformerHooks {
+    constructor() {
     }
     onProgramTransformStart(options: CompilationOptions, program: Program) {
-        if (this.dumpAst) {
-            console.log(`BEFORE ${this.pluginName}:`);
-            dumpProgramSrcFormatted(program, true);
-        }
         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();
     }
 }
 
@@ -73,7 +50,8 @@ export function runTransformerOnProgram(
     options: CompilationOptions,
     transform: ProgramTransformer | undefined,
     pluginContext: PluginContext,
-    hooks: RunTransformerHooks = {}
+    hooks: RunTransformerHooks,
+    stableDeps: boolean,
 ) {
     arktsGlobal.filePath = program.absoluteName;
 
@@ -82,14 +60,19 @@ export function runTransformerOnProgram(
     // Perform some additional actions before the transformation start
     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);
@@ -102,10 +85,12 @@ export function runTransformer(
     state: Es2pandaContextState,
     transform: ProgramTransformer | undefined,
     pluginContext: PluginContext,
-    hooks: RunTransformerHooks = {}
+    stableDeps: boolean = false,
 ) {
+    const hooks = new ProfilerHooks()
+
     // 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();
@@ -118,7 +103,7 @@ export function runTransformer(
             state,
         };
 
-        runTransformerOnProgram(currentProgram, options, transform, pluginContext, hooks);
+        runTransformerOnProgram(currentProgram, options, transform, pluginContext, hooks, stableDeps);
 
         // The first program is always the main program
         isMainProgram = false;
@@ -134,3 +119,50 @@ function isProgramForCodegeneration(program: Program, isMainProgram: boolean): b
     }
     return program.isGenAbcForExternal;
 }
+
+const isDebugDump: boolean = false;
+
+function checkDebugDump() {
+    return isDebugDump || process.env.KOALA_DUMP_PLUGIN_AST == "1";
+}
+
+export function debugDump(
+    dumpDir: string | undefined,
+    state: Es2pandaContextState,
+    pluginName: string,
+    isAfter: boolean,
+    program: Program,
+) {
+    if (!checkDebugDump()) {
+        return;
+    }
+    if (!dumpDir) {
+        const outDir = global.arktsconfig?.outDir
+        if (outDir) {
+            dumpDir = path.join(outDir, "../dist/cache")
+        } else {
+            dumpDir = "dist/cache"
+        }
+    }
+    const baseDir = path.join(dumpDir,
+        `${state}_${isAfter ? "" : "ORI"}_${pluginName}`
+    );
+    runTransformer(
+        program,
+        state,
+        (program: Program) => {
+            if (program.absoluteName == "") {
+                return
+            }
+            const dumpFilePath = path.join(baseDir, path.sep + program.absoluteName)
+            fs.mkdirSync(path.dirname(dumpFilePath), { recursive: true })
+            fs.writeFileSync(
+                dumpFilePath,
+                program.ast.dumpSrc(),
+                'utf-8',
+            )
+        },
+        new PluginContextImpl(),
+        true,
+    )
+}

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

@@ -14,6 +14,8 @@
  */
 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 {
@@ -24,8 +26,8 @@ export {
     passStringArray,
     unpackNode,
     unpackString,
-    assertValidPeer,
     updateNodeByNode,
+    unpackNativeObjectArray,
 } from './arkts-api/utilities/private';
 export { nodeByType } from './arkts-api/class-by-peer';
 export { global } from './arkts-api/static/global';

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

@@ -41,7 +41,7 @@ export class Tracer {
             return;
         }
         const programPath = program.absoluteName;
-        if (programPath == '') {
+        if (!programPath.length) {
             return;
         }
         const suggestedTracer = Tracer.Tracers.get(programPath);
@@ -123,7 +123,7 @@ export class Tracer {
                 this.trace(`${`Event "${event}"`.padEnd(maxLength)}: ${eventCnt}`);
                 this.eventsPerContext?.forEach((localizedEventsMap: Map<string, number>, context: string) => {
                     localizedEventsMap.forEach((localizedEventCnt: number, localizedEvent: string) => {
-                        if (localizedEvent == event) {
+                        if (localizedEvent === event) {
                             this.trace(`${`  in context [${context}]`.padEnd(maxLength)}: ${localizedEventCnt}`);
                         }
                     });

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

@@ -22,7 +22,7 @@ export function withWarning<T>(value: T, message: string): T {
     return value;
 }
 
-export function isNumber(value: any): value is number {
+export function isNumber(value: unknown): value is number {
     return typeof value === `number`;
 }
 
@@ -72,11 +72,11 @@ function replaceIllegalHashes(code: string): string {
 function replaceGensymWrappers(code: string): string {
     const indices = [...code.matchAll(/\({let/g)].map((it) => it.index);
     const replacements: string[][] = [];
-    for (var i of indices) {
+    for (let i of indices) {
         if (!i) {
             continue;
         }
-        var j = i + 1,
+        let j: number = i + 1,
             depth = 1;
         while (j < code.length) {
             if (code[j] == '(') {
@@ -91,7 +91,7 @@ function replaceGensymWrappers(code: string): string {
             j++;
         }
 
-        if (j == code.length) {
+        if (j === code.length) {
             continue;
         }
 
@@ -104,7 +104,7 @@ function replaceGensymWrappers(code: string): string {
             /^\({let ([_%a-zA-Z0-9]+?) = (?!\({let)([\s\S]*?);\n([\s\S]*?)}\)$/g,
             (match, name: string, val: string, expr: string) => {
                 let rightExpr = expr.slice(expr.lastIndexOf(name) + name.length, -1);
-                if (rightExpr[0] != '.') {
+                if (rightExpr[0] !== '.') {
                     rightExpr = `.${rightExpr}`;
                 }
                 return `(${val}?${rightExpr})`;
@@ -112,7 +112,7 @@ function replaceGensymWrappers(code: string): string {
         );
         replacements.push([base, fixed]);
     }
-    for (var [b, f] of replacements) {
+    for (let [b, f] of replacements) {
         code = code.replace(b, f);
     }
     return code;
@@ -153,7 +153,7 @@ function addExports(code: string): string {
         ['export @memo_stable()', '@memo_stable() export'],
         ['export class OhosRouter', 'export default class OhosRouter'],
     ];
-    for (var [f, t] of fix) {
+    for (let [f, t] of fix) {
         code = code.replaceAll(f, t);
     }
     return code.replaceAll('\nexport function main()', '\nfunction main()');
@@ -179,15 +179,15 @@ function fixEnums(code: string) {
     }
     enums.forEach((name) => {
         const regexp = new RegExp(`${name}\\.(\\w+)(.)`, `g`);
-        code = code.replaceAll(regexp, (match, p1, p2) => {
-            if (!p1.startsWith('_') && p2 == ':') {
+        code = code.replaceAll(regexp, (match: string, p1: string, p2: string) => {
+            if (!p1.startsWith('_') && p2 === ':') {
                 // this colon is for switch case, not for type
                 return `${name}.${p1}.valueOf()${p2}`;
             }
             return match;
         });
         const idents = [...code.matchAll(new RegExp(`(\\w+?)([\\W])(\\w+?): ${name}`, `g`))]
-            .filter((it) => it[1] != 'readonly' && it[1] != '_get')
+            .filter((it) => it[1] !== 'readonly' && it[1] !== '_get')
             .map((it) => it[3]);
         // work manually with a couple of cases not to write one more bracket parser
         if (code.includes(`const eventKind = (deserializer.readInt32() as CallbackEventKind);`)) {
@@ -245,7 +245,3 @@ export function filterSource(text: string): string {
     // console.error(dumperUnwrappers.reduceRight((code, f) => f(code), text).split('\n').map((it, index) => `${`${index + 1}`.padStart(4)} |${it}`).join('\n'))
     return dumperUnwrappers.reduceRight((code, f) => f(code), text);
 }
-
-export function getEnumName(enumType: any, value: number): string | undefined {
-    return enumType[value];
-}

package/build/libarkts-copy/tsconfig.json

@@ -10,8 +10,5 @@
     "include": [
         "./src/**/*.ts",
         "./generated/**/*.ts"
-    ],
-    "exclude": [
-        "./src/ts-api/**/*.ts"
     ]
 }