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

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

@@ -14,11 +14,10 @@
  */
 
 import { KNativePointer } from '@koalaui/interop';
-import { ETSModule, ImportDeclaration, isETSImportDeclaration, Program, Statement } from '../../generated';
+import { ETSImportDeclaration, isETSImportDeclaration, Program, Statement } from '../../generated';
 import { passNode, passNodeArray, unpackNonNullableNode } from './utilities/private';
 import { global } from './static/global';
 import { Es2pandaImportFlags, Es2pandaImportKinds } from '../../generated/Es2pandaEnums';
-import { factory } from './factory/nodeFactory';
 
 export class ImportStorage {
     // Improve: migrate to wrappers instead of pointers
@@ -48,12 +47,18 @@ export class ImportStorage {
         const newStatements: Statement[] = [];
         for (const statement of statements) {
             if (isETSImportDeclaration(statement) && !this.imports.has(statement.peer)) {
+                // Weak workaround to avoid self-imports (see panda issue 31156)
+                if (this.program.moduleName == statement.source?.str || this.program.moduleName == `${statement.source?.str}.index`) {
+                    continue
+                }
+
+                // On checked state imports from unparsed sources cannot be inserted
                 if (!this.isParserState && !this.importSources.has(statement.source?.str)) {
                     console.warn('Attempt to insert import from new source after parsed state:');
                     console.warn(statement.dumpSrc());
                 }
 
-                const importDeclaration = unpackNonNullableNode<ImportDeclaration>(
+                const importDeclaration = unpackNonNullableNode<ETSImportDeclaration>(
                     // Note: this call is important, we cannot just pass "statement" to "InsertETSImportDeclarationAndParse"
                     global.es2panda._ETSParserBuildImportDeclaration(
                         global.context,

package/build/libarkts-copy/src/arkts-api/factory/nodeFactory.ts

@@ -30,6 +30,7 @@ import {
     TryStatement,
     TSTypeParameter,
     VariableDeclarator,
+    OverloadDeclaration,
 } from '../../../generated';
 import { factory as generatedFactory } from '../../../generated/factory';
 import {
@@ -59,6 +60,7 @@ import { createArrayExpression, updateArrayExpression } from '../node-utilities/
 import { updateBlockStatement } from '../node-utilities/BlockStatement';
 import { updateETSModule } from '../node-utilities/ETSModule';
 import { createOpaqueTypeNode } from '../node-utilities/OpaqueTypeNode';
+import { createOverloadDeclaration } from '../node-utilities/OverloadDeclaration';
 
 export const factory = {
     ...generatedFactory,
@@ -141,4 +143,6 @@ export const factory = {
     updateClassStaticBlock: ClassStaticBlock.updateClassStaticBlock,
 
     createOpaqueTypeNode,
+
+    createOverloadDeclaration,
 };

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

@@ -33,7 +33,6 @@ export { GlobalContext } from './peers/Context';
 export * from './peers/ExternalSource';
 export * from './peers/Options';
 export * from './node-utilities/ArkTsConfig';
-export * from './node-utilities/Program';
 export * from './peers/ImportPathManager';
 export * from './static/globalUtils';
 export { global as arktsGlobal } from './static/global';

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

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2024 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 { Expression, OverloadDeclaration } from '../../../generated';
+import { Es2pandaOverloadDeclFlags, Es2pandaModifierFlags } from '../../../generated/Es2pandaEnums';
+
+export function createOverloadDeclaration(
+    key: Expression | undefined,
+    overloads: readonly Expression[],
+    flags: Es2pandaOverloadDeclFlags,
+    modifiers: Es2pandaModifierFlags,
+): OverloadDeclaration {
+    const res = OverloadDeclaration.createOverloadDeclaration(key, modifiers);
+    res.setOverloadedList(overloads)
+    res.addOverloadDeclFlag(flags)
+    return res
+}

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

@@ -49,7 +49,6 @@ export class Context extends ArktsObject {
     }
 
     static createFromFile(filePath: string): Context {
-        return new Context(global.generatedEs2panda._CreateContextFromStringWithHistory(global.config, passString(filePath), passString(filePath)));
         return new Context(global.generatedEs2panda._CreateContextFromFile(global.config, passString(filePath)));
     }
 

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

@@ -18,7 +18,6 @@ import { ETSModule, Program } from '../../generated';
 import { ExternalSource } from './peers/ExternalSource';
 import { KNativePointer, nullptr } from '@koalaui/interop';
 import { global } from './static/global';
-import { RunTransformerHooks } from '../plugin-utils';
 import { Context } from './peers/Context';
 
 export interface CompilationOptions {
@@ -61,6 +60,7 @@ export interface ProjectConfig {
     integratedHsp: boolean;
     frameworkMode?: string;
     isUi2abc?: boolean;
+    memoPluginOptions?: Object;
 }
 
 export interface PluginContextBase {
@@ -84,6 +84,8 @@ export interface PluginContext extends PluginContextBase {
     getCodingFilePath(): string | undefined
 
     isCoding(): boolean
+
+    getProjectConfig(): ProjectConfig | undefined 
 }
 
 
@@ -232,12 +234,3 @@ export function listPrograms(program: Program, filter: (name: string) => boolean
         }),
     ];
 }
-
-export interface PluginEntry {
-    name?: string;
-    parsed?: (hooks?: RunTransformerHooks) => void;
-    checked?: (hooks?: RunTransformerHooks) => void;
-    clean?: (hooks?: RunTransformerHooks) => void;
-}
-
-export type PluginInitializer = (parsedJson?: object, checkedJson?: object) => PluginEntry;

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

@@ -94,9 +94,6 @@ export class global {
 
     public static profiler = new Profiler();
 
-    // Check node type values during node creation
-    public static validatePeerTypes = false;
-
     public static clearContext(): void {
         global.compilerContext = undefined;
     }

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

@@ -101,16 +101,16 @@ export class Profiler implements PerformanceData {
         this.transformDepStartTime = Date.now();
     }
 
-    transformEnded(state: Es2pandaContextState, pluginName: string): void {
+    transformEnded(): void {
         const transformEndTime = Date.now();
         const consumedTime = transformEndTime - this.transformStartTime;
-        this.getPluginData(pluginName, state).transformTime += consumedTime;
+        this.getPluginData(this.curPlugin, this.curContextState).transformTime += consumedTime;
     }
 
-    transformDepEnded(state: Es2pandaContextState, pluginName: string): void {
+    transformDepEnded(): void {
         const transformEndTime = Date.now();
         const consumedTime = transformEndTime - this.transformDepStartTime;
-        this.getPluginData(pluginName, state).transformTimeDeps += consumedTime;
+        this.getPluginData(this.curPlugin, this.curContextState).transformTimeDeps += consumedTime;
     }
 
     proceededToState(consumedTime: number) {

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

@@ -32,40 +32,6 @@ export const allFlags = Object.values(Es2pandaModifierFlags)
     .filter(isNumber)
     .reduce((prev, next) => prev | next, 0);
 
-export function assertValidPeer(peer: KPtr, expectedKind: Es2pandaAstNodeType): void {
-    if (peer === nullptr) {
-        throwError(`invalid peer`);
-    }
-
-    if (global.validatePeerTypes) {
-        const peerType = global.generatedEs2panda._AstNodeTypeConst(global.context, peer);
-        if (
-            peerType === Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION &&
-            expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION
-        ) {
-            // Improve: Struct is a child class of Class
-            return;
-        }
-        if (
-            peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION &&
-            expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION
-        ) {
-            // Improve: ETSImportDeclaration is a child of a ImportDeclaration
-            return;
-        }
-        if (
-            peerType === Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE &&
-            expectedKind === Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT
-        ) {
-            // Improve: ETSModule is a child of a BlockStatement
-            return;
-        }
-        if (peerType !== expectedKind) {
-            throwError(`expected: ${Es2pandaAstNodeType[expectedKind]}, got: ${Es2pandaAstNodeType[peerType]}`);
-        }
-    }
-}
-
 export function acceptNativeObjectArrayResult<T extends ArktsObject>(
     arrayObject: KNativePointer,
     factory: (instance: KNativePointer) => T
@@ -106,6 +72,13 @@ export function unpackNodeArray<T extends AstNode>(nodesPtr: KNativePointer, typ
     return new NativePtrDecoder().decode(nodesPtr).map((peer: KNativePointer) => unpackNonNullableNode(peer, typeHint));
 }
 
+export function unpackNativeObjectArray<T extends ArktsObject>(
+    arrayObject: KNativePointer,
+    factory: (instance: KNativePointer) => T
+): T[] {
+    return acceptNativeObjectArrayResult(arrayObject, factory);
+}
+
 export function passNodeArray(nodes: readonly ArktsObject[] | undefined): BigUint64Array {
     return new BigUint64Array(nodes?.filter((it) => (!!it.peer))?.map((node) => BigInt(node.peer)) ?? []);
 }

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

@@ -28,7 +28,6 @@ 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';

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 && !program.absoluteName.includes("absolute-sdk-patched")) {
-            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 && !program.absoluteName.includes("absolute-sdk-patched")) {
-            console.log(`AFTER ${this.pluginName}:`);
-            dumpProgramSrcFormatted(program, true);
-        }
+        if (!options.isProgramForCodegeneration) arktsGlobal.profiler.transformDepEnded();
     }
 }
 
@@ -73,8 +50,8 @@ export function runTransformerOnProgram(
     options: CompilationOptions,
     transform: ProgramTransformer | undefined,
     pluginContext: PluginContext,
-    hooks: RunTransformerHooks = {},
-    stableDeps: boolean = false,
+    hooks: RunTransformerHooks,
+    stableDeps: boolean,
 ) {
     arktsGlobal.filePath = program.absoluteName;
 
@@ -108,9 +85,10 @@ 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, stableDeps);
 
@@ -141,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

@@ -26,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/tsconfig.json

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