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

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

@@ -37,9 +37,6 @@ import { Es2pandaPluginDiagnosticType } from '../generated/Es2pandaEnums';
 export type KPtrArray = BigUint64Array;
 
 export class Es2pandaNativeModule {
-    _AnnotationAllowedAnnotations(context: KPtr, node: KPtr, returnLen: KPtr): KPtr {
-        throw new Error('Not implemented');
-    }
     _AstNodeRebind(context: KPtr, node: KPtr): void {
         throw new Error('Not implemented');
     }
@@ -64,9 +61,6 @@ export class Es2pandaNativeModule {
     _HasGlobalStructInfo(context: KNativePointer, str: String): KBoolean {
         throw new Error('Not implemented');
     }
-    _DestroyContext(context: KPtr): void {
-        throw new Error('Not implemented');
-    }
     _ProceedToState(context: KPtr, state: number): void {
         throw new Error('Not implemented');
     }
@@ -91,9 +85,6 @@ export class Es2pandaNativeModule {
     _VariableDeclaration(context: KPtr, variable: KPtr): KPtr {
         throw new Error('Not implemented');
     }
-    _DeclNode(context: KPtr, decl: KPtr): KPtr {
-        throw new Error('Not implemented');
-    }
     _ProgramSourceFilePath(context: KNativePointer, instance: KNativePointer): KNativePointer {
         throw new Error('Not implemented');
     }
@@ -141,47 +132,6 @@ export class Es2pandaNativeModule {
     _OptionsArkTsConfig(context: KNativePointer, options: KNativePointer): KNativePointer {
         throw new Error('Not implemented');
     }
-    _Checker_CreateOpaqueTypeNode(context: KNativePointer, type: KNativePointer): KNativePointer {
-        throw new Error('Not implemented');
-    }
-    _Checker_ScriptFunctionSignature(context: KNativePointer, node: KNativePointer): KNativePointer {
-        throw new Error('Not implemented');
-    }
-    _Checker_ScriptFunctionSetSignature(
-        context: KNativePointer,
-        node: KNativePointer,
-        signature: KNativePointer
-    ): void {
-        throw new Error('Not implemented');
-    }
-    _Checker_SignatureReturnType(context: KNativePointer, signature: KNativePointer): KNativePointer {
-        throw new Error('Not implemented');
-    }
-    _Checker_ScriptFunctionGetPreferredReturnType(context: KNativePointer, node: KNativePointer): KNativePointer {
-        throw new Error('Not implemented');
-    }
-    _Checker_ScriptFunctionSetPreferredReturnType(
-        context: KNativePointer,
-        node: KNativePointer,
-        type: KNativePointer
-    ): void {
-        throw new Error('Not implemented');
-    }
-    _Checker_ExpressionGetPreferredType(context: KNativePointer, node: KNativePointer): KNativePointer {
-        throw new Error('Not implemented');
-    }
-    _Checker_ExpressionSetPreferredType(context: KNativePointer, node: KNativePointer, type: KNativePointer): void {
-        throw new Error('Not implemented');
-    }
-    _Checker_TypeToString(context: KNativePointer, type: KNativePointer): KNativePointer {
-        throw new Error('Not implemented');
-    }
-    _Checker_TypeClone(context: KNativePointer, type: KNativePointer): KNativePointer {
-        throw new Error('Not implemented');
-    }
-    _Checker_TypeNodeGetType(context: KNativePointer, node: KNativePointer): KNativePointer {
-        throw new Error('Not implemented');
-    }
     _ScriptFunctionSetParams(
         context: KNativePointer,
         receiver: KNativePointer,
@@ -234,12 +184,6 @@ export class Es2pandaNativeModule {
     _SetUpSoPath(soPath: string): void {
         throw new Error('Not implemented');
     }
-    _MemInitialize(): void {
-        throw new Error('Not implemented');
-    }
-    _MemFinalize(): void {
-        throw new Error('Not implemented');
-    }
     _ProgramCanSkipPhases(context: KNativePointer, program: KNativePointer): KBoolean {
         throw new Error('Not implemented');
     }

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

@@ -29,11 +29,9 @@ export * from './ProgramProvider';
 export * from './peers/AstNode';
 export * from './peers/Config';
 export * from './peers/Context';
-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/OpaqueTypeNode.ts

@@ -20,7 +20,7 @@ import { Es2pandaAstNodeType } from '../../../generated/Es2pandaEnums';
 
 export function createOpaqueTypeNode(typePointer: KNativePointer): OpaqueTypeNode {
     return new OpaqueTypeNode(
-        global.es2panda._Checker_CreateOpaqueTypeNode(global.context, typePointer),
+        global.generatedEs2panda._CreateOpaqueTypeNode(global.context, typePointer),
         Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE
     );
 }

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

@@ -14,111 +14,77 @@
  */
 
 import { ArktsObject } from './ArktsObject';
-import { Program } from '../../../generated';
+import { compiler, Program } from '../../../generated';
 import { global } from '../static/global';
-import { passString, passStringArray } from '../utilities/private';
 import { KNativePointer, nullptr, KBoolean } from '@koalaui/interop';
 import { Config } from './Config';
-import { filterSource, throwError } from '../../utils';
+import { filterSource } from '../../utils';
 import { AstNode } from './AstNode';
 
+// Perhaps, this file would become generated some time later
+// Please, do not add hard logic here
+
 export class Context extends ArktsObject {
     constructor(peer: KNativePointer) {
         super(peer);
     }
 
     static createFromString(source: string): Context {
-        if (!global.configIsInitialized()) {
-            throw new Error(`Config not initialized`);
-        }
-        return new Context(
-            global.generatedEs2panda._CreateContextFromString(global.config, passString(source), passString(global.filePath))
-        );
+        return compiler.createContextFromString(global.configObj, source, global.filePath);
     }
 
-    /** @deprecated Use {@link createCacheFromFile} instead */
     static createCacheContextFromFile(
         configPtr: KNativePointer,
         fileName: string,
         globalContextPtr: KNativePointer,
         isExternal: KBoolean
     ): Context {
-        return new Context(
-            global.generatedEs2panda._CreateCacheContextFromFile(configPtr, passString(fileName), globalContextPtr, isExternal)
-        );
+        return compiler.createCacheContextFromFile(new Config(configPtr), fileName, new GlobalContext(globalContextPtr), isExternal);
     }
 
     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)));
+        return compiler.createContextFromFile(global.configObj, filePath);
     }
 
-    static createCacheFromFile(filePath: string, config: Config, globalContext: GlobalContext, isExternal: boolean) {
-        return new Context(
-            global.generatedEs2panda._CreateCacheContextFromFile(
-                config.peer,
-                passString(filePath),
-                globalContext.peer,
-                isExternal
-            )
-        );
+    static createCacheFromFile(filePath: string, config: Config, globalContext: GlobalContext, isExternal: boolean): Context {
+        return compiler.createCacheContextFromFile(config, filePath, globalContext, isExternal);
     }
 
     static createContextGenerateAbcForExternalSourceFiles(filenames: string[]): Context {
-        if (!global.configIsInitialized()) {
-            throwError(`Config not initialized`);
-        }
-        return new Context(
-            global.generatedEs2panda._CreateContextGenerateAbcForExternalSourceFiles(
-                global.config,
-                filenames.length,
-                passStringArray(filenames)
-            )
-        );
+        return compiler.createContextGenerateAbcForExternalSourceFiles(global.configObj, filenames);
     }
 
-    destroy() {
-        if (this.peer !== nullptr) {
-            global.es2panda._DestroyContext(this.peer);
-            this.peer = nullptr;
-        }
+    static createFromStringWithHistory(source: string): Context {
+        return compiler.createContextFromStringWithHistory(global.configObj, source, global.filePath);
+    }
+
+    destroy(): void {
+        compiler.destroyContext();
     }
 
     /** @deprecated */
     static destroyAndRecreate(ast: AstNode): Context {
         console.log('[TS WRAPPER] DESTROY AND RECREATE');
         const source = filterSource(ast.dumpSrc());
-        global.es2panda._DestroyContext(global.context);
-        global.compilerContext = Context.createFromString(source) as any; // Improve: commonize Context
-
-        return new Context(global.context);
+        compiler.destroyContext();
+        return global.compilerContext = Context.createFromString(source);
     }
 
     get program(): Program {
-        return new Program(global.generatedEs2panda._ContextProgram(this.peer));
+        return compiler.contextProgram();
     }
 }
 
 export class GlobalContext extends ArktsObject {
-    static create(config: Config, externalFileList: string[]): GlobalContext {
-        return new GlobalContext(
-            global.generatedEs2panda._CreateGlobalContext(
-                config.peer,
-                passStringArray(externalFileList),
-                externalFileList.length,
-                false
-            )
-        );
-    }
-
     constructor(peer: KNativePointer) {
         super(peer);
     }
 
+    static create(config: Config, externalFileList: string[]): GlobalContext {
+        return compiler.createGlobalContext(config, externalFileList, false);
+    }
+
     destroy() {
-        if (this.peer !== nullptr) {
-            global.generatedEs2panda._DestroyGlobalContext(this.peer);
-            this.peer = nullptr;
-        }
+        compiler.destroyGlobalContext();
     }
 }

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

@@ -13,11 +13,13 @@
  * limitations under the License.
  */
 
-import { global } from '../static/global';
-import { acceptNativeObjectArrayResult, unpackString } from '../utilities/private';
-import { KNativePointer, nullptr } from '@koalaui/interop';
+import { KNativePointer } from '@koalaui/interop';
 import { Program } from '../../../generated';
 import { ArktsObject } from './ArktsObject';
+import { compiler } from '../../../generated';
+
+// Perhaps, this file would become generated some time later
+// Please, do not add hard logic here
 
 export class ExternalSource extends ArktsObject {
     constructor(peer: KNativePointer) {
@@ -25,17 +27,10 @@ export class ExternalSource extends ArktsObject {
     }
 
     getName(): string {
-        return unpackString(global.es2panda._ExternalSourceName(this.peer));
-    }
-
-    get programs(): Program[] {
-        return acceptNativeObjectArrayResult<Program>(
-            global.es2panda._ExternalSourcePrograms(this.peer),
-            (instance: KNativePointer) => new Program(instance)
-        );
+        return compiler.externalSourceName(this);
     }
 
-    static instantiate(peer: KNativePointer) {
-        return new ExternalSource(peer);
+    get programs(): readonly Program[] {
+        return compiler.externalSourcePrograms(this);
     }
 }

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 
 }
 
 
@@ -221,10 +223,10 @@ export function defaultFilter(name: string): boolean {
     return true;
 }
 
-export function listPrograms(program: Program, filter: (name: string) => boolean = defaultFilter): Program[] {
+export function listPrograms(program: Program, filter: (name: string) => boolean = defaultFilter): readonly Program[] {
     return [
         program,
-        ...program.getExternalSources().flatMap((it: ExternalSource): Program[] => {
+        ...program.getExternalSources().flatMap((it: ExternalSource): readonly Program[] => {
             if (filter(it.getName())) {
                 return it.programs;
             }
@@ -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

@@ -40,6 +40,7 @@ export class UpdateTracker {
 }
 
 export class global {
+    /** @deprecated */
     public static filePath: string = './plugins/input/main.ets';
 
     public static arktsconfig?: ArkTsConfig;
@@ -68,7 +69,6 @@ export class global {
 
     // Improve: rename to context when the pointer valued one is eliminated
     public static compilerContext: Context | undefined;
-    public static isContextGenerateAbcForExternalSourceFiles: boolean = false;
 
     private static _es2panda: Es2pandaNativeModule | undefined = undefined;
     public static get es2panda(): Es2pandaNativeModule {
@@ -79,6 +79,13 @@ export class global {
     }
 
     private static _generatedEs2panda: GeneratedEs2pandaNativeModule | undefined = undefined;
+    /**
+     * @deprecated
+     * 
+     * You should not generally use generatedEs2panda in handwritten code
+     * (only in exceptional cases).
+     * Please use generated wrapper for native call instead.
+     */
     public static get generatedEs2panda(): GeneratedEs2pandaNativeModule {
         if (this._generatedEs2panda === undefined) {
             this._generatedEs2panda = initGeneratedEs2panda();
@@ -94,9 +101,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/extensions.ts

@@ -61,14 +61,14 @@ export function extension_MethodDefinitionOnUpdate(this: MethodDefinition, origi
 
 // Improve: generate checker related stuff
 export function extension_ScriptFunctionGetSignaturePointer(this: ScriptFunction): KNativePointer {
-    return global.es2panda._Checker_ScriptFunctionSignature(global.context, this.peer);
+    return global.generatedEs2panda._ScriptFunctionSignature(global.context, this.peer);
 }
 
 export function extension_ScriptFunctionSetSignaturePointer(
     this: ScriptFunction,
     signaturePointer: KNativePointer
 ): void {
-    global.es2panda._Checker_ScriptFunctionSetSignature(global.context, this.peer, signaturePointer);
+    global.generatedEs2panda._ScriptFunctionSetSignature(global.context, this.peer, signaturePointer);
 }
 
 // Improve: weird API
@@ -81,23 +81,23 @@ export function extension_ScriptFunctionGetParamsCasted(this: ScriptFunction): r
 
 // 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.generatedEs2panda._ScriptFunctionGetPreferredReturnType(global.context, this.peer);
 }
 
 export function extension_ScriptFunctionSetPreferredReturnTypePointer(
     this: ScriptFunction,
     typePointer: KNativePointer
 ): void {
-    global.es2panda._Checker_ScriptFunctionSetPreferredReturnType(global.context, this.peer, typePointer);
+    global.generatedEs2panda._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.generatedEs2panda._ExpressionPreferredTypeConst(global.context, this.peer);
 }
 
 export function extension_ExpressionSetPreferredTypePointer(this: Expression, typePointer: KNativePointer): void {
-    global.es2panda._Checker_ExpressionSetPreferredType(global.context, this.peer, typePointer);
+    global.generatedEs2panda._ExpressionSetPreferredType(global.context, this.peer, typePointer);
 }
 
 // Improve: weird API
@@ -108,12 +108,9 @@ export function extension_ProgramGetAstCasted(this: Program): ETSModule {
     );
 }
 
-// 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
-    );
+/** @deprecated Now generated */
+export function extension_ProgramGetExternalSources(this: Program): readonly ExternalSource[] {
+    return this.externalSources;
 }
 
 // Improve: SourcePositionLine is global in idl

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,16 @@ 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[] {
+    if (arrayObject == nullptr) {
+        return [];
+    }
+    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/arkts-api/utilities/public.ts

@@ -70,6 +70,7 @@ import { Context } from '../peers/Context';
 import { NodeCache } from '../node-cache';
 import { factory } from '../factory/nodeFactory';
 import { traceGlobal } from '../../tracer';
+import { compiler } from '../../../generated';
 
 /**
  * Improve: Replace or remove with better naming
@@ -292,7 +293,7 @@ export function getAnnotations(node: AstNode): readonly AnnotationUsage[] {
     if (!isFunctionDeclaration(node) && !isScriptFunction(node) && !isClassDefinition(node)) {
         throwError('for now annotations allowed only for: functionDeclaration, scriptFunction, classDefinition');
     }
-    return unpackNodeArray(global.es2panda._AnnotationAllowedAnnotations(global.context, node.peer, nullptr));
+    return unpackNodeArray(global.generatedEs2panda._AnnotationAllowedAnnotations(global.context, node.peer));
 }
 
 export function getOriginalNode(node: AstNode): AstNode {
@@ -411,14 +412,14 @@ export function signatureReturnType(signature: KNativePointer): KNativePointer {
     if (!signature) {
         return nullptr;
     }
-    return global.es2panda._Checker_SignatureReturnType(global.context, signature);
+    return global.generatedEs2panda._SignatureReturnType(global.context, signature);
 }
 
 export function convertCheckerTypeToTypeNode(typePeer: KNativePointer | undefined): TypeNode | undefined {
     if (!typePeer) {
         return undefined;
     }
-    return factory.createOpaqueTypeNode(global.es2panda._Checker_TypeClone(global.context, typePeer));
+    return factory.createOpaqueTypeNode(global.generatedEs2panda._TypeClone(global.context, typePeer));
 }
 
 export function originalSourcePositionString(node: AstNode | undefined) {
@@ -521,10 +522,12 @@ export function filterNodesByTypes(node: AstNode, types: Es2pandaAstNodeType[]):
     return unpackNodeArray(global.es2panda._FilterNodes3(global.context, passNode(node), typesArray, types.length));
 }
 
+// This functions are used as capitalized in build-system, unlike the others
+// See https://gitcode.com/openharmony/arkcompiler_ets_frontend/issues/8196
 export function MemInitialize() {
-    global.es2panda._MemInitialize()
+    compiler.memInitialize()
 }
 
 export function MemFinalize() {
-    global.es2panda._MemFinalize()
+    compiler.memFinalize()
 }