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

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

@@ -14,110 +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._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

@@ -223,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;
             }

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();

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

@@ -76,6 +76,9 @@ export function unpackNativeObjectArray<T extends ArktsObject>(
     arrayObject: KNativePointer,
     factory: (instance: KNativePointer) => T
 ): T[] {
+    if (arrayObject == nullptr) {
+        return [];
+    }
     return acceptNativeObjectArrayResult(arrayObject, factory);
 }
 

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()
 }

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

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

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

@@ -25,6 +25,7 @@ import {
     ProgramProvider,
     CompilationOptions,
     PluginContextImpl,
+    Es2pandaCompilationMode,
 } from './arkts-api';
 import { Tracer } from './tracer';
 import { global } from "./arkts-api/static/global";
@@ -114,7 +115,7 @@ export function runTransformer(
 }
 
 function isProgramForCodegeneration(program: Program, isMainProgram: boolean): boolean {
-    if (!arktsGlobal.isContextGenerateAbcForExternalSourceFiles) {
+    if (arktsGlobal.configObj?.compilationMode != Es2pandaCompilationMode.COMPILATION_MODE_GEN_ABC_FOR_EXTERNAL_SOURCE) {
         return isMainProgram;
     }
     return program.isGenAbcForExternal;

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

@@ -13,11 +13,12 @@
  * limitations under the License.
  */
 export { KNativePointer } from '@koalaui/interop';
+export { ArktsObject, isSameNativeObject } from './arkts-api/peers/ArktsObject';
 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 { ExternalSource } from './arkts-api/peers/ExternalSource';
 export {
     passNode,
     unpackNonNullableNode,