@idlizer/arktscgen 2.1.2 → 2.1.7

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

@@ -13,16 +13,16 @@
  * limitations under the License.
  */
 
-import { isNullPtr, KInt, KNativePointer as KPtr, KNativePointer, nullptr } from "@koalaui/interop"
+import { isNullPtr, KInt, KNativePointer, nullptr } from "@koalaui/interop"
 import { global } from "../static/global"
-import { allFlags, nodeType, unpackNodeArray, unpackNonNullableNode, unpackString } from "../utilities/private"
+import { allFlags, unpackNodeArray, unpackNonNullableNode, unpackString } from "../utilities/private"
 import { throwError } from "../../utils"
 import { Es2pandaModifierFlags } from "../../generated/Es2pandaEnums"
 import { ArktsObject } from "./ArktsObject"
-import { Es2pandaAstNodeType } from "../../Es2pandaEnums"
 
 export abstract class AstNode extends ArktsObject {
     protected constructor(peer: KNativePointer) {
+        global.profiler.createdNodes ++
         if (isNullPtr(peer)) {
             throwError(`attempted to create AstNode from nullptr`)
         }
@@ -31,7 +31,12 @@ export abstract class AstNode extends ArktsObject {
     }
 
     public get originalPeer(): KNativePointer {
-        return global.generatedEs2panda._AstNodeOriginalNodeConst(global.context, this.peer)
+        const result = global.generatedEs2panda._AstNodeOriginalNodeConst(global.context, this.peer)
+        if (result === nullptr) {
+            this.originalPeer = this.peer
+            return this.peer
+        }
+        return result
     }
 
     public set originalPeer(peer: KNativePointer) {
@@ -69,7 +74,7 @@ export abstract class AstNode extends ArktsObject {
             .map((it) => it.dump(indentation + 1))
         const msg =
             `${indentation}_`
-            + ` <mods: ${this.modifiers}>`
+            + ` <mods: ${this.modifierFlags}>`
             + this.dumpMessage()
         return "> " + " ".repeat(4 * indentation) + msg + "\n" + children.join("")
     }
@@ -90,6 +95,10 @@ export abstract class AstNode extends ArktsObject {
         return unpackString(global.es2panda._AstNodeDumpModifiers(global.context, this.peer))
     }
 
+    public clone(): this {
+        return unpackNonNullableNode(global.generatedEs2panda._AstNodeClone(global.context, this.peer, this.parent.peer));
+    }
+
     public get parent(): AstNode {
         const parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer)
         if (parent === nullptr) {
@@ -102,20 +111,12 @@ export abstract class AstNode extends ArktsObject {
         global.generatedEs2panda._AstNodeSetParent(global.context, this.peer, node.peer)
     }
 
-    public get modifiers(): KInt {
+    public get modifierFlags(): Es2pandaModifierFlags {
         return global.generatedEs2panda._AstNodeModifiers(global.context, this.peer)
     }
 
-    public set modifiers(flags: KInt | undefined) {
+    public set modifierFlags(flags: KInt | undefined) {
         global.generatedEs2panda._AstNodeClearModifier(global.context, this.peer, allFlags)
         global.generatedEs2panda._AstNodeAddModifier(global.context, this.peer, flags ?? Es2pandaModifierFlags.MODIFIER_FLAGS_NONE)
     }
 }
-
-
-export class UnsupportedNode extends AstNode {
-    constructor(peer: KPtr) {
-        super(peer)
-        console.warn(`Warning: unsupported node ${Es2pandaAstNodeType[nodeType(this)]}`)
-    }
-}

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

@@ -16,7 +16,6 @@
 import { ArktsObject } from "./ArktsObject"
 import { Program } from "./Program"
 import { global } from "../static/global"
-import { throwError } from "../../utils"
 import { passString } from "../utilities/private"
 import { KNativePointer } from "@koalaui/interop"
 
@@ -29,7 +28,7 @@ export class Context extends ArktsObject {
         source: string
     ): Context {
         if (!global.configIsInitialized()) {
-            throwError(`Config not initialized`)
+            throw new Error(`Config not initialized`)
         }
         return new Context(
             global.es2panda._CreateContextFromString(

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

@@ -0,0 +1,30 @@
+/*
+ * 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 { ArktsObject } from "./ArktsObject"
+import { global } from "../static/global"
+import { KNativePointer } from "@koalaui/interop"
+
+export class ImportPathManager extends ArktsObject {
+    constructor(peer: KNativePointer) {
+        super(peer)
+    }
+
+    static create(): ImportPathManager {
+        return new ImportPathManager(
+            global.es2panda._ETSParserGetImportPathManager(global.context)
+        );
+    }
+}

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

@@ -16,7 +16,7 @@
 import { ArktsObject } from "./ArktsObject"
 import { global } from "../static/global"
 import { acceptNativeObjectArrayResult, unpackString } from "../utilities/private"
-import { KNativePointer } from "@koalaui/interop"
+import { KNativePointer, nullptr } from "@koalaui/interop"
 import { ETSModule } from "../../generated"
 
 export class Program extends ArktsObject {
@@ -25,14 +25,16 @@ export class Program extends ArktsObject {
     }
 
     get astNode(): ETSModule {
-        return new ETSModule(global.es2panda._ProgramAst(global.context, this.peer));
+        let program = global.es2panda._ProgramAst(global.context, this.peer)
+        if (program == nullptr) throw new Error(`astNode() cannt get AST`)
+        return new ETSModule(program)
     }
 
     get externalSources(): ExternalSource[] {
         return acceptNativeObjectArrayResult<ExternalSource>(
             global.es2panda._ProgramExternalSources(global.context, this.peer),
             (instance: KNativePointer) => new ExternalSource(instance)
-        );
+        )
     }
 
 }
@@ -43,13 +45,13 @@ export class ExternalSource extends ArktsObject {
     }
 
     getName(): string {
-        return unpackString(global.es2panda._ExternalSourceName(this.peer));
+        return unpackString(global.es2panda._ExternalSourceName(this.peer))
     }
 
     get programs(): Program[] {
         return acceptNativeObjectArrayResult<Program>(
             global.es2panda._ExternalSourcePrograms(this.peer),
             (instance: KNativePointer) => new Program(instance)
-        );
+        )
     }
 }

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

@@ -0,0 +1,38 @@
+/*
+ * 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 { ArktsObject } from "./ArktsObject"
+import { global } from "../static/global"
+import { KNativePointer } from "@koalaui/interop"
+
+export class SourcePosition extends ArktsObject {
+    constructor(peer: KNativePointer) {
+        super(peer)
+    }
+
+    static create(index: number, line: number): SourcePosition {
+        return new SourcePosition(
+            global.es2panda._CreateSourcePosition(global.context, index, line)
+        );
+    }
+
+    index(): number {
+        return global.es2panda._SourcePositionIndex(global.context, this.peer);
+    }
+
+    line(): number {
+        return global.es2panda._SourcePositionLine(global.context, this.peer);
+    }
+}

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

@@ -0,0 +1,48 @@
+/*
+ * 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 { Es2pandaContextState } from "../generated/Es2pandaEnums"
+import { ExternalSource, Program } from "./peers/Program"
+
+export interface CompilationOptions {
+    readonly isMainProgram: boolean,
+    readonly name: string,
+    readonly stage: Es2pandaContextState,
+}
+
+export type ProgramTransformer = (program: Program, compilationOptions: CompilationOptions) => void
+
+export function defaultFilter(name: string) {
+    if (name.startsWith("std.")) return false
+    if (name.startsWith("escompat")) return false
+    return true
+}
+
+export interface ProgramWithName {
+    program: Program,
+    name: string
+}
+
+export function listPrograms(program: Program, filter: (name: string) => boolean = defaultFilter): ProgramWithName[] {
+    return [
+        { program, name: "" },
+        ...program.externalSources.flatMap((it: ExternalSource) => {
+            if (filter(it.getName())) {
+                return it.programs.map(program => ({ program, name: it.getName() } as ProgramWithName))
+            }
+            return []
+        })
+    ]
+}

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

@@ -14,14 +14,17 @@
  */
 
 import { throwError } from "../../utils"
-import { KNativePointer } from "@koalaui/interop"
+import { KNativePointer, nullptr } from "@koalaui/interop"
 import { initEs2panda, Es2pandaNativeModule, initGeneratedEs2panda } from "../../Es2pandaNativeModule"
 import { Es2pandaNativeModule as GeneratedEs2pandaNativeModule } from "../../generated/Es2pandaNativeModule"
 import { initInterop, InteropNativeModule } from "../../InteropNativeModule"
 import { Context } from "../peers/Context"
+import { Profiler } from "./profiler"
+import { Program } from "../peers/Program"
 
 export class global {
     public static filePath: string = "./plugins/input/main.ets"
+    public static packageName: string = ""
     public static filePathFromPackageRoot: string = global.filePath
 
     private static _config?: KNativePointer
@@ -32,7 +35,7 @@ export class global {
         return global._config ?? throwError('Global.config not initialized')
     }
     public static configIsInitialized(): boolean {
-        return global._config !== undefined
+        return global._config !== undefined && global._config !== nullptr
     }
 
     // TODO: rename to contextPeer
@@ -63,5 +66,8 @@ export class global {
     public static get interop(): InteropNativeModule {
         if (this._interop === undefined) this._interop = initInterop()
         return this._interop
+
     }
+
+    public static profiler = new Profiler()
 }

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

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2022-2023 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.
+ */
+
+export class Profiler {
+    totalTime = 0
+    transformTime = 0
+    proceedTime = 0
+    restartTime = 0
+    visitedNodes = 0
+    createdNodes = 0
+
+    report() {
+        console.log(
+            "total compiler:",
+            this.totalTime,
+            " proceeds:",
+            this.proceedTime,
+            " restarts",
+            this.restartTime,
+            " transforms:",
+            this.transformTime,
+            " visited:",
+            this.visitedNodes,
+            " created:",
+            this.createdNodes
+        )
+    }
+}

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

@@ -21,15 +21,13 @@ import {
     KNativePointer,
     nullptr,
     withString,
-    withStringArray,
-    withStringResult
+    withStringArray
 } from "@koalaui/interop"
 import { NativePtrDecoder } from "./nativePtrDecoder"
-import { Es2pandaModifierFlags, Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums"
+import { Es2pandaAstNodeType, Es2pandaModifierFlags, Es2pandaScriptFunctionFlags } from "../../generated/Es2pandaEnums"
 import { classByPeer } from "../class-by-peer"
-import type { AstNode } from "../peers/AstNode"
+import { AstNode } from "../peers/AstNode"
 import { ArktsObject } from "../peers/ArktsObject"
-import { Es2pandaAstNodeType } from "../../Es2pandaEnums"
 
 export const arrayOfNullptr = new BigUint64Array([nullptr])
 
@@ -39,7 +37,6 @@ export const allFlags =
         .reduce(
             (prev, next) => prev | next,
             0
-
         )
 
 export function assertValidPeer(peer: KPtr, expectedKind: Es2pandaAstNodeType): void {
@@ -72,21 +69,20 @@ export function unpackNonNullableNode<T extends AstNode>(peer: KNativePointer):
     if (peer === nullptr) {
         throwError('peer is NULLPTR (maybe you should use unpackNode)')
     }
-    return classByPeer(peer) as T
+    return classByPeer(peer)
 }
 
 export function unpackNode<T extends AstNode>(peer: KNativePointer): T | undefined {
     if (peer === nullptr) {
         return undefined
     }
-    return classByPeer(peer) as T
+    return classByPeer<T>(peer)
 }
 
 export function passNode(node: ArktsObject | undefined): KNativePointer {
     return node?.peer ?? nullptr
 }
 
-// meaning unpackNonNullableNodeArray
 export function unpackNodeArray<T extends AstNode>(nodesPtr: KNativePointer): T[] {
     if (nodesPtr === nullptr) {
         throwError('nodesPtr is NULLPTR (maybe you should use unpackNodeArray)')
@@ -96,9 +92,12 @@ export function unpackNodeArray<T extends AstNode>(nodesPtr: KNativePointer): T[
         .map((peer: KNativePointer) => unpackNonNullableNode(peer))
 }
 
-export function passNodeArray(nodes: readonly AstNode[] | undefined): BigUint64Array {
+export function passNodeArray(nodes: readonly ArktsObject[] | undefined): BigUint64Array {
     return new BigUint64Array(
-        nodes?.map(node => BigInt(node.peer)) ?? []
+        nodes
+            ?.filter(it => it.peer != undefined)
+            ?.map(node => BigInt(node.peer))
+        ?? []
     )
 }
 
@@ -117,9 +116,10 @@ export function unpackObject<T extends ArktsObject>(type: { new (peer: KNativePo
 }
 
 export function unpackString(peer: KNativePointer): string {
-    return withStringResult(peer) ?? throwError(`failed to unpack (peer shouldn't be NULLPTR)`)
+    return global.interop._RawUtf8ToString(peer)
 }
 
+// TODO: use direct string arguments instead.
 export function passString(str: string | undefined): string {
     if (str === undefined) {
         return ""
@@ -127,12 +127,14 @@ export function passString(str: string | undefined): string {
     return withString(str, (it: string) => it)
 }
 
+
+// TODO: use direct string arguments instead.
 export function passStringArray(strings: readonly string[]): string[] {
     return withStringArray(strings, (it: string[]) => it)
 }
 
 export function passNodeWithNewModifiers<T extends AstNode>(node: T, modifiers: KInt): T {
-    return (unpackNonNullableNode(node.peer) as T).updateModifiers(modifiers)
+    return unpackNonNullableNode<T>(node.peer).updateModifiers(modifiers)
 }
 
 export function scriptFunctionHasBody(peer: KNativePointer): boolean {
@@ -145,7 +147,9 @@ export function updateNodeByNode<T extends ArktsObject>(node: T, original: T): T
     if (original.peer === nullptr) {
         throwError('update called on NULLPTR')
     }
-    global.generatedEs2panda._AstNodeSetOriginalNode(global.context, node.peer, original.peer)
+    if (original instanceof AstNode) {
+        global.generatedEs2panda._AstNodeSetOriginalNode(global.context, node.peer, original.originalPeer)
+    }
     global.generatedEs2panda._AstNodeSetParent(global.context, node.peer, global.generatedEs2panda._AstNodeParent(global.context, original.peer))
     global.es2panda._AstNodeUpdateChildren(global.context, node.peer)
     return node

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

@@ -15,24 +15,33 @@
 
 import { global } from "../static/global"
 import { isNumber, throwError } from "../../utils"
-import { nullptr, withStringResult } from "@koalaui/interop"
+import { KNativePointer, nullptr } from "@koalaui/interop"
 import { passNode, passNodeArray, unpackNodeArray, unpackNonNullableNode } from "./private"
 import { Es2pandaContextState, Es2pandaModifierFlags } from "../../generated/Es2pandaEnums"
 import type { AstNode } from "../peers/AstNode"
 import {
     type AnnotationUsage,
     ClassDefinition,
+    ClassProperty,
+    ETSImportDeclaration,
     ETSModule,
     isClassDefinition,
+    isFunctionDeclaration,
     isMemberExpression,
     isScriptFunction,
-    isFunctionDeclaration
+    isIdentifier,
+    isETSModule
 } from "../../generated"
 import { Config } from "../peers/Config"
 import { Context } from "../peers/Context"
+import { NodeCache } from "../node-cache"
 
-export function createETSModulefromContext(): ETSModule {
-    return new ETSModule(global.es2panda._ProgramAst(global.context, global.es2panda._ContextProgram(global.context)))
+export function createETSModuleFromContext(): ETSModule {
+    let program = global.es2panda._ContextProgram(global.context)
+    if (program == nullptr) {
+        throw new Error(`Program is null for context ${global.context.toString(16)}`)
+    }
+    return new ETSModule(global.es2panda._ProgramAst(global.context, program))
 }
 
 export function createETSModuleFromSource(
@@ -44,7 +53,10 @@ export function createETSModuleFromSource(
     }
     global.compilerContext = Context.createFromString(source)
     proceedToState(state)
-    return new ETSModule(global.es2panda._ProgramAst(global.context, global.es2panda._ContextProgram(global.context)))
+    let program = global.es2panda._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.es2panda._ProgramAst(global.context, program))
 }
 
 export function updateETSModuleByStatements(
@@ -55,11 +67,7 @@ export function updateETSModuleByStatements(
     return node
 }
 
-export function proceedToState(state: Es2pandaContextState): void {
-    if (state <= global.es2panda._ContextState(global.context)) {
-        return
-    }
-    global.es2panda._ProceedToState(global.context, state)
+export function checkErrors() {
     if (global.es2panda._ContextState(global.context) === Es2pandaContextState.ES2PANDA_STATE_ERROR) {
         console.log()
         global.es2panda._DestroyConfig(global.config)
@@ -68,23 +76,41 @@ export function proceedToState(state: Es2pandaContextState): void {
     }
 }
 
+export function proceedToState(state: Es2pandaContextState): void {
+    if (state <= global.es2panda._ContextState(global.context)) {
+        return
+    }
+    const before = Date.now()
+    global.es2panda._ProceedToState(global.context, state)
+    const after = Date.now()
+    global.profiler.proceedTime += after-before
+    NodeCache.clear()
+    checkErrors()
+}
+
 export function startChecker(): boolean {
     return global.es2panda._CheckerStartChecker(global.context)
 }
 
 export function recheckSubtree(node: AstNode): void {
     global.es2panda._AstNodeRecheck(global.context, node.peer)
+    checkErrors()
 }
 
 export function rebindSubtree(node: AstNode): void {
     global.es2panda._AstNodeRebind(global.context, node.peer)
+    checkErrors()
 }
 
 export function getDecl(node: AstNode): AstNode | undefined {
     if (isMemberExpression(node)) {
-        return getDecl(node.property)
+        return getDecl(node.property!)
     }
-    const decl = global.es2panda._DeclarationFromIdentifier(global.context, passNode(node))
+    return getPeerDecl(passNode(node))
+}
+
+export function getPeerDecl(peer: KNativePointer): AstNode | undefined {
+    const decl = global.es2panda._DeclarationFromIdentifier(global.context, peer)
     if (decl === nullptr) {
         return undefined
     }
@@ -113,6 +139,10 @@ export function getFileName(): string {
     return global.filePath
 }
 
+export function getPackageName(): string {
+    return global.packageName
+}
+
 export function getFilePathFromPackageRoot(): string {
     return global.filePathFromPackageRoot
 }
@@ -125,6 +155,28 @@ export function classDefinitionFlags(node: ClassDefinition): Es2pandaModifierFla
     return global.generatedEs2panda._AstNodeModifiers(global.context, node.peer)
 }
 
+// TODO: ClassProperty's optional flag is set by AstNode's modifiers flags.
+export function classPropertySetOptional(node: ClassProperty, value: boolean): ClassProperty {
+    if (value) {
+        node.modifierFlags |= Es2pandaModifierFlags.MODIFIER_FLAGS_OPTIONAL;
+    } else {
+        node.modifierFlags &= Es2pandaModifierFlags.MODIFIER_FLAGS_OPTIONAL;
+    }
+    return node;
+}
+
+export function hasModifierFlag(node: AstNode, flag: Es2pandaModifierFlags): boolean {
+    if (!node) return false;
+
+    let modifiers;
+    if (isClassDefinition(node)) {
+        modifiers = classDefinitionFlags(node);
+    } else {
+        modifiers = node.modifierFlags
+    }
+    return (modifiers & flag) === flag;
+}
+
 export function modifiersToString(modifiers: Es2pandaModifierFlags): string {
      return Object.values(Es2pandaModifierFlags)
             .filter(isNumber)
@@ -133,3 +185,15 @@ export function modifiersToString(modifiers: Es2pandaModifierFlags): string {
                 return ((modifiers.valueOf() & it) === it) ? Es2pandaModifierFlags[it] : ""
             }).join(" ")
 }
+
+export function nameIfIdentifier(node: AstNode): string {
+    return isIdentifier(node) ? `'${node.name}'` : ""
+}
+
+export function nameIfETSModule(node: AstNode): string {
+    return isETSModule(node) ? `'${node.ident?.name}'` : ""
+}
+
+export function asString(node: AstNode|undefined): string {
+    return `${node?.constructor.name} ${node ? nameIfIdentifier(node) : undefined}`
+}