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

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

@@ -20,9 +20,7 @@ import {
     passNode,
     unpackNodeArray,
     unpackNonNullableNode,
-    passString,
     unpackString,
-    passStringArray,
     unpackNode,
 } from './private';
 import {
@@ -30,20 +28,18 @@ import {
     Es2pandaModifierFlags,
     Es2pandaMethodDefinitionKind,
     Es2pandaAstNodeType,
-    Es2pandaPluginDiagnosticType,
 } from '../../../generated/Es2pandaEnums';
 import type { AstNode } from '../peers/AstNode';
 import {
-    DiagnosticInfo,
+    AnnotationAllowed,
     Identifier,
     isConditionalExpression,
     SourcePosition,
-    SourceRange,
-    SuggestionInfo,
     VariableDeclarator,
 } from '../../../generated';
 import {
-    type AnnotationUsage,
+    AnnotationUsage,
+    compiler,
     ClassDefinition,
     ClassProperty,
     ETSModule,
@@ -63,7 +59,6 @@ import {
     MemberExpression,
     isMethodDefinition,
     TypeNode,
-    DiagnosticKind
 } from '../../../generated';
 import { Config } from '../peers/Config';
 import { Context } from '../peers/Context';
@@ -77,15 +72,8 @@ import { traceGlobal } from '../../tracer';
  * @deprecated
  */
 export function createETSModuleFromContext(): ETSModule {
-    let program = global.generatedEs2panda._ContextProgram(global.context);
-    if (program === nullptr || program === null) {
-        throw new Error(`Program is null for context ${global.context.toString(16)}`);
-    }
-    const ast = global.generatedEs2panda._ProgramAst(global.context, program);
-    if (ast === nullptr || ast === null) {
-        throw new Error(`AST is null for program ${program.toString(16)}`);
-    }
-    return new ETSModule(ast, Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE);
+    const program = compiler.contextProgram();
+    return program.getAstCasted();
 }
 
 /**
@@ -103,13 +91,8 @@ export function createETSModuleFromSource(
     }
     global.compilerContext = Context.createFromString(source);
     proceedToState(state);
-    let program = global.generatedEs2panda._ContextProgram(global.compilerContext.peer);
-    if (program === nullptr)
-        throw new Error(`Program is null for ${source} 0x${global.compilerContext.peer.toString(16)}`);
-    return new ETSModule(
-        global.generatedEs2panda._ProgramAst(global.context, program),
-        Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE
-    );
+    const program = compiler.contextProgram();
+    return program.getAstCasted();
 }
 
 export function metaDatabase(fileName: string): string {
@@ -117,26 +100,31 @@ export function metaDatabase(fileName: string): string {
     return `${fileName}.meta.json`;
 }
 
-export function checkErrors() {
-    if (global.es2panda._ContextState(global.context) === Es2pandaContextState.ES2PANDA_STATE_ERROR) {
+export function checkErrors(proceedTo?: string) {
+    if (compiler.contextState() === Es2pandaContextState.ES2PANDA_STATE_ERROR) {
         traceGlobal(() => `Terminated due to compilation errors occured`);
-        console.log(unpackString(global.generatedEs2panda._GetAllErrorMessages(global.context)));
-        // global.es2panda._DestroyConfig(global.config)
-        throw new Error(`Compilation error`)
-    }
-}
-
-function format(value: number): string {
-    return `${(value / 1024 / 1024 / 1024).toFixed(4)} GB`
-}
 
-// Improve: move to profiler
-function dumpMemoryProfilerInfo(str: string) {
-    console.log(str, format(process.memoryUsage().rss));
+        const errorMessage = compiler.contextErrorMessage();
+        if (errorMessage === undefined) {
+            throwError(`Could not get ContextErrorMessage`);
+        }
+        const allErrorMessages = compiler.getAllErrorMessages();
+        if (allErrorMessages === undefined) {
+            throwError(`Could not get AllErrorMessages`);
+        }
+        const actionMsg = proceedTo ? " to " + proceedTo : ""
+        throwError([`Failed to proceed${actionMsg}`, errorMessage, allErrorMessages].join(`\n`));
+    }
 }
 
-export function proceedToState(state: Es2pandaContextState): void {
-    if (state <= global.es2panda._ContextState(global.context)) {
+export function proceedToState(state: Es2pandaContextState, _contextPtr?: KNativePointer, ignoreErrors = false): void {
+    if (compiler.contextState() === Es2pandaContextState.ES2PANDA_STATE_ERROR) {
+        NodeCache.clear();
+        if (!ignoreErrors) {
+            checkErrors(Es2pandaContextState[state]);
+        }
+    }
+    if (state <= compiler.contextState()) {
         return;
     }
     NodeCache.clear();
@@ -146,17 +134,16 @@ export function proceedToState(state: Es2pandaContextState): void {
     traceGlobal(() => `Proceeding to state ${Es2pandaContextState[state]}: done`);
     const after = Date.now();
     global.profiler.proceededToState(after - before);
-    if (state == Es2pandaContextState.ES2PANDA_STATE_BIN_GENERATED) {
-        dumpMemoryProfilerInfo("Memory usage (rss) after proceed to bin:")
+    if (!ignoreErrors) {
+        checkErrors(Es2pandaContextState[state]);
     }
-    checkErrors();
 }
 
 /** @deprecated Use {@link rebindContext} instead */
 export function rebindSubtree(node: AstNode): void {
     NodeCache.clear();
     traceGlobal(() => `Rebind: start`);
-    global.es2panda._AstNodeRebind(global.context, node.peer);
+    compiler.astNodeRebind(node);
     traceGlobal(() => `Rebind: done`);
     checkErrors();
 }
@@ -165,18 +152,14 @@ export function rebindSubtree(node: AstNode): void {
 export function recheckSubtree(node: AstNode): void {
     NodeCache.clear();
     traceGlobal(() => `Recheck: start`);
-    global.generatedEs2panda._AstNodeRecheck(global.context, node.peer);
+    compiler.astNodeRecheck(node);
     traceGlobal(() => `Recheck: done`);
-    checkErrors();
 }
 
 export function rebindContext(context: KNativePointer = global.context): void {
     NodeCache.clear();
     traceGlobal(() => `Rebind: start`);
-    global.es2panda._AstNodeRebind(
-        context,
-        global.generatedEs2panda._ProgramAst(context, global.generatedEs2panda._ContextProgram(context))
-    );
+    compiler.astNodeRebind(compiler.contextProgram().getAstCasted());
     traceGlobal(() => `Rebind: done`);
     checkErrors();
 }
@@ -184,10 +167,7 @@ export function rebindContext(context: KNativePointer = global.context): void {
 export function recheckContext(context: KNativePointer = global.context): void {
     NodeCache.clear();
     traceGlobal(() => `Recheck: start`);
-    global.generatedEs2panda._AstNodeRecheck(
-        context,
-        global.generatedEs2panda._ProgramAst(context, global.generatedEs2panda._ContextProgram(context))
-    );
+    compiler.astNodeRecheck(compiler.contextProgram().getAstCasted());
     traceGlobal(() => `Recheck: done`);
     checkErrors();
 }
@@ -256,10 +236,6 @@ export function getPeerDecl(peer: KNativePointer): AstNode | undefined {
     return unpackNonNullableNode(decl);
 }
 
-export function declarationFromIdentifier(node: Identifier): AstNode | undefined {
-    return unpackNode(global.generatedEs2panda._DeclarationFromIdentifier(global.context, node.peer));
-}
-
 export function resolveGensymVariableDeclaratorForDefaultParam(node: VariableDeclarator): Identifier | undefined {
     const init = node.init;
     if (
@@ -280,6 +256,14 @@ export function resolveGensymVariableDeclaratorForOptionalCall(node: VariableDec
     return undefined;
 }
 
+export function getPeerIdentifierDecl(peer: KNativePointer): AstNode | undefined {
+    const decl = global.generatedEs2panda._DeclarationFromIdentifier(global.context, peer);
+    if (decl === nullptr) {
+        return undefined;
+    }
+    return unpackNonNullableNode(decl);
+}
+
 export function getPeerObjectDecl(peer: KNativePointer): AstNode | undefined {
     const decl = global.es2panda._ClassVariableDeclaration(global.context, peer);
     if (decl === nullptr) {
@@ -288,11 +272,28 @@ export function getPeerObjectDecl(peer: KNativePointer): AstNode | undefined {
     return unpackNonNullableNode(decl);
 }
 
+export function getPeerMemberDecl(peer: KNativePointer): AstNode | undefined {
+    const decl = global.es2panda._DeclarationFromMemberExpression(global.context, peer);
+    if (decl === nullptr) {
+        return undefined;
+    }
+    return unpackNonNullableNode(decl);
+}
+
+export function getPeerPropertyDecl(peer: KNativePointer): AstNode | undefined {
+    const decl = global.es2panda._DeclarationFromProperty(global.context, peer);
+    if (decl === nullptr) {
+        return undefined;
+    }
+    return unpackNonNullableNode(decl);
+}
+
+
 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 new AnnotationAllowed(node.peer).annotations
 }
 
 export function getOriginalNode(node: AstNode): AstNode {
@@ -320,7 +321,7 @@ export function getJsDoc(node: AstNode): string | undefined {
 // Use this function if you need
 // the language level modifiers: public, declare, export, etc.
 export function classDefinitionFlags(node: ClassDefinition): Es2pandaModifierFlags {
-    return global.generatedEs2panda._AstNodeModifiers(global.context, node.peer);
+    return node.modifierFlags
 }
 
 // Improve: ClassProperty's optional flag is set by AstNode's modifiers flags.
@@ -376,25 +377,6 @@ export function findStdlib(): string {
     return `${sdk}/ets/stdlib`;
 }
 
-export function generateTsDeclarationsFromContext(
-    outputDeclEts: string,
-    outputEts: string,
-    exportAll: boolean,
-    isolated: boolean,
-    recordFile: string,
-    genAnnotations: boolean
-): KInt {
-    return global.generatedEs2panda._GenerateTsDeclarationsFromContext(
-        global.context,
-        passString(outputDeclEts),
-        passString(outputEts),
-        exportAll,
-        isolated,
-        recordFile,
-        genAnnotations
-    );
-}
-
 export function setAllParents(ast: AstNode): void {
     global.es2panda._AstNodeUpdateAll(global.context, ast.peer);
 }
@@ -404,21 +386,21 @@ export function getProgramFromAstNode(node: AstNode): Program {
 }
 
 export function importDeclarationInsert(node: ETSImportDeclaration, program: Program): void {
-    global.generatedEs2panda._InsertETSImportDeclarationAndParse(global.context, program.peer, node.peer);
+    compiler.insertETSImportDeclarationAndParse(program, node);
 }
 
 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) {
@@ -437,10 +419,6 @@ export function originalSourcePositionString(node: AstNode | undefined) {
     return `[${program.absoluteName}${sourcePosition.toString()}]`;
 }
 
-export function generateStaticDeclarationsFromContext(outputPath: string): KInt {
-    return global.generatedEs2panda._GenerateStaticDeclarationsFromContext(global.context, passString(outputPath));
-}
-
 export function createTypeNodeFromTsType(node: AstNode): AstNode | undefined {
     const typeAnnotation = global.es2panda._CreateTypeNodeFromTsType(global.context, node.peer);
     if (typeAnnotation === nullptr) {
@@ -449,62 +427,6 @@ export function createTypeNodeFromTsType(node: AstNode): AstNode | undefined {
     return unpackNonNullableNode(typeAnnotation);
 }
 
-export function createSourcePosition(index: KUInt, line: KUInt): SourcePosition {
-    return new SourcePosition(global.generatedEs2panda._CreateSourcePosition(global.context, index, line));
-}
-
-export function createSourceRange(start: SourcePosition, end: SourcePosition): SourceRange {
-    return new SourceRange(global.generatedEs2panda._CreateSourceRange(global.context, start.peer, end.peer));
-}
-
-export function createDiagnosticInfo(
-    kind: DiagnosticKind,
-    position: SourcePosition,
-    ...args: string[]
-): DiagnosticInfo {
-    return new DiagnosticInfo(
-        global.generatedEs2panda._CreateDiagnosticInfo(
-            global.context,
-            kind.peer,
-            passStringArray(args),
-            args.length,
-            position.peer
-        )
-    );
-}
-
-export function createSuggestionInfo(
-    kind: DiagnosticKind,
-    substitutionCode: string,
-    title: string,
-    range: SourceRange,
-    ...args: string[]
-): SuggestionInfo {
-    return new SuggestionInfo(
-        global.generatedEs2panda._CreateSuggestionInfo(
-            global.context,
-            kind.peer,
-            passStringArray(args),
-            args.length,
-            substitutionCode,
-            title,
-            range.peer
-        )
-    );
-}
-
-export function createDiagnosticKind(message: string, type: Es2pandaPluginDiagnosticType): DiagnosticKind {
-    return new DiagnosticKind(global.es2panda._CreateDiagnosticKind(global.context, message, type));
-}
-
-export function logDiagnostic(kind: DiagnosticKind, pos: SourcePosition, ...args: string[]): void {
-    global.es2panda._LogDiagnostic(global.context, kind.peer, passStringArray(args), args.length, pos.peer);
-}
-
-export function logDiagnosticWithSuggestion(diagnosticInfo: DiagnosticInfo, suggestionInfo: SuggestionInfo): void {
-    global.generatedEs2panda._LogDiagnosticWithSuggestion(global.context, diagnosticInfo.peer, suggestionInfo.peer);
-}
-
 export function filterNodes(node: AstNode, filter: string, deeperAfterMatch: boolean): AstNode[] {
     return unpackNodeArray(global.es2panda._FilterNodes(global.context, passNode(node), filter, deeperAfterMatch));
 }
@@ -521,10 +443,8 @@ export function filterNodesByTypes(node: AstNode, types: Es2pandaAstNodeType[]):
     return unpackNodeArray(global.es2panda._FilterNodes3(global.context, passNode(node), typesArray, types.length));
 }
 
-export function MemInitialize() {
-    global.es2panda._MemInitialize()
-}
-
-export function MemFinalize() {
-    global.es2panda._MemFinalize()
+export function jumpFromETSTypeReferenceToTSTypeAliasDeclarationTypeAnnotation(node: AstNode): AstNode | undefined {
+    return unpackNode(
+        global.es2panda._JumpFromETSTypeReferenceToTSTypeAliasDeclarationTypeAnnotation(global.context, passNode(node))
+    );
 }

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

@@ -19,6 +19,7 @@ import {
     ArrayExpression,
     ArrowFunctionExpression,
     AssignmentExpression,
+    AwaitExpression,
     BinaryExpression,
     BlockExpression,
     BlockStatement,
@@ -764,6 +765,7 @@ function visitClassProperty(node: ClassProperty, visitor: Visitor): ClassPropert
             result.onUpdate(node);
             return result;
         }
+        node.setKey(newKey);
         node.setValue(newValue);
         node.setTypeAnnotation(newTypeAnnotation);
         node.setAnnotations(newAnnotations);
@@ -773,12 +775,12 @@ function visitClassProperty(node: ClassProperty, visitor: Visitor): ClassPropert
 
 function visitProperty(node: Property, visitor: Visitor): Property {
     global.updateTracker.push();
+    const oldKey = node.key;
     const newKey = nodeVisitor(node.key, visitor);
     const newValue = nodeVisitor(node.value, visitor);
     if (global.updateTracker.check()) {
-        const result = factory.createProperty(node.kind, newKey, newValue, node.isMethod, node.isComputed);
-        result.onUpdate(node);
-        return result;
+        node.setKey(newKey);
+        node.setValue(newValue);
     }
     return node;
 }
@@ -957,6 +959,17 @@ function visitClassStaticBlock(node: ClassStaticBlock, visitor: Visitor): ClassS
     return node;
 }
 
+function visitAwaitExpression(node: AwaitExpression, visitor: Visitor): AwaitExpression {
+    global.updateTracker.push();
+    const newArgument = nodeVisitor(node.argument, visitor);
+    if (global.updateTracker.check()) {
+        const result = factory.createAwaitExpression(newArgument);
+        result.onUpdate(node);
+        return result;
+    }
+    return node;
+}
+
 const visitsTable: (((node: any, visitor: Visitor) => any) | undefined)[] = [];
 
 export function initVisitsTable(): void {
@@ -1017,6 +1030,7 @@ export function initVisitsTable(): void {
     visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION] = visitTSTypeParameterDeclaration;
     visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION] = visitTSTypeParameterInstantiation;
     visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK] = visitClassStaticBlock;
+    visitsTable[Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION] = visitAwaitExpression;
 }
 
 initVisitsTable();

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,

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

@@ -245,3 +245,7 @@ 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];
+}