@idlizer/arktscgen 2.1.5 → 2.1.9-arktscgen-4

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

@@ -0,0 +1,30 @@
+/*
+ * 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 { TSTypeParameterInstantiation, TypeNode } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateTSTypeParameterInstantiation(
+    original: TSTypeParameterInstantiation,
+    params: readonly TypeNode[]
+): TSTypeParameterInstantiation {
+    if (isSameNativeObject(params, original.params)) {
+        return original;
+    }
+
+    const update = updateThenAttach(TSTypeParameterInstantiation.updateTSTypeParameterInstantiation, attachModifiers);
+    return update(original, params);
+}

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

@@ -22,7 +22,7 @@ export function updateETSTypeReferencePart(
     name?: Expression,
     typeParams?: TSTypeParameterInstantiation,
     prev?: ETSTypeReferencePart
-) {
+): ETSTypeReferencePart {
     if (isSameNativeObject(name, original.name)
         && isSameNativeObject(typeParams, original.typeParams)
         && isSameNativeObject(prev, original.previous)

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

@@ -0,0 +1,35 @@
+/*
+ * 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 { TemplateLiteral, TemplateElement, Expression } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateTemplateLiteral(
+    original: TemplateLiteral,
+    quasis: readonly TemplateElement[],
+    expressions: readonly Expression[],
+    multilineString: string
+): TemplateLiteral {
+    if (
+        isSameNativeObject(quasis, original.quasis) &&
+        isSameNativeObject(expressions, original.expressions)
+    ) {
+        return original;
+    }
+
+    const update = updateThenAttach(TemplateLiteral.updateTemplateLiteral, attachModifiers);
+    return update(original, quasis, expressions, multilineString);
+}

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

@@ -0,0 +1,24 @@
+/*
+ * 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 { ThisExpression } from '../../generated';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateThisExpression(original: ThisExpression): ThisExpression {
+    /* TODO: no getter provided yet */
+
+    const update = updateThenAttach(ThisExpression.updateThisExpression, attachModifiers);
+    return update(original);
+}

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

@@ -0,0 +1,24 @@
+/*
+ * 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 { UndefinedLiteral } from '../../generated';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateUndefinedLiteral(original: UndefinedLiteral): UndefinedLiteral {
+    /* TODO: no getter provided yet */
+
+    const update = updateThenAttach(UndefinedLiteral.updateUndefinedLiteral, attachModifiers);
+    return update(original);
+}

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

@@ -40,7 +40,7 @@ export function updateVariableDeclaration(
     kind: Es2pandaVariableDeclarationKind,
     declarators: readonly VariableDeclarator[],
     annotations?: readonly AnnotationUsage[]
-) {
+): VariableDeclaration {
     if (isSameNativeObject(kind, original.kind)
         && isSameNativeObject(declarators, original.declarators)
         && isSameNativeObject(annotations, original.annotations)

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

@@ -23,7 +23,7 @@ export function updateVariableDeclarator(
     flag: Es2pandaVariableDeclaratorFlag,
     ident?: Expression,
     init?: Expression
-) {
+): VariableDeclarator {
     if (isSameNativeObject(flag, original.flag)
         && isSameNativeObject(ident, original.id)
         && isSameNativeObject(init, original.init)

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

@@ -20,7 +20,9 @@ export abstract class ArktsObject {
         this.peer = peer
     }
 
-    readonly peer: KNativePointer
+    peer: KNativePointer
+
+    public onUpdate(node: ArktsObject) {}
 }
 
 export function isSameNativeObject<T extends ArktsObject | number | string | boolean | undefined>(

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

@@ -13,21 +13,24 @@
  * 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 { Es2pandaAstNodeType, Es2pandaModifierFlags } from "../../generated/Es2pandaEnums"
+import { Es2pandaModifierFlags } from "../../generated/Es2pandaEnums"
 import { ArktsObject } from "./ArktsObject"
+import { SourcePosition } from "./SourcePosition"
+import { NodeCache } from "../node-cache"
 
 export abstract class AstNode extends ArktsObject {
     protected constructor(peer: KNativePointer) {
-        global.profiler.createdNodes ++
+        global.profiler.nodeCreated()
         if (isNullPtr(peer)) {
             throwError(`attempted to create AstNode from nullptr`)
         }
         super(peer)
         this.updateChildren()
+        NodeCache.addToCache(peer, this)
     }
 
     public get originalPeer(): KNativePointer {
@@ -56,11 +59,12 @@ export abstract class AstNode extends ArktsObject {
         )
     }
 
-    public updateChildren(): void {
+    public updateChildren(): this {
         if (this.peer === nullptr) {
             throwError('updateChildren called on NULLPTR')
         }
         global.es2panda._AstNodeUpdateChildren(global.context, this.peer)
+        return this
     }
 
     public updateModifiers(modifierFlags: KInt | undefined): this {
@@ -95,20 +99,37 @@ 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) {
+    //         throwError(`no parent`)
+    //     }
+    //     return unpackNonNullableNode(parent)
+    // }
+
+    // public set parent(node: AstNode) {
+    //     global.generatedEs2panda._AstNodeSetParent(global.context, this.peer, node.peer)
+    // }
+
     public clone(): this {
-        return unpackNonNullableNode(global.generatedEs2panda._AstNodeClone(global.context, this.peer, this.parent.peer));
+        const clonedNode = unpackNonNullableNode(
+            global.generatedEs2panda._AstNodeClone(global.context, this.peer, this.parent?.peer ?? nullptr)
+        );
+        clonedNode.parent = undefined;
+        return clonedNode as this;
     }
-
-    public get parent(): AstNode {
-        const parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer)
-        if (parent === nullptr) {
-            throwError(`no parent`)
-        }
-        return unpackNonNullableNode(parent)
+    
+    public get parent(): AstNode | undefined {
+        const parent = global.generatedEs2panda._AstNodeParent(global.context, this.peer);
+        return unpackNonNullableNode(parent);
     }
 
-    public set parent(node: AstNode) {
-        global.generatedEs2panda._AstNodeSetParent(global.context, this.peer, node.peer)
+    public set parent(node: AstNode | undefined) {
+        global.generatedEs2panda._AstNodeSetParent(global.context, this.peer, node?.peer ?? nullptr);
     }
 
     public get modifierFlags(): Es2pandaModifierFlags {
@@ -119,4 +140,46 @@ export abstract class AstNode extends ArktsObject {
         global.generatedEs2panda._AstNodeClearModifier(global.context, this.peer, allFlags)
         global.generatedEs2panda._AstNodeAddModifier(global.context, this.peer, flags ?? Es2pandaModifierFlags.MODIFIER_FLAGS_NONE)
     }
+    
+    /** @deprecated Use {@link modifierFlags} instead */
+    public get modifiers(): KInt {
+        return this.modifierFlags
+    }
+
+    /** @deprecated Use {@link modifierFlags} instead */
+    public set modifiers(flags: KInt | undefined) {
+        this.modifierFlags = flags
+    }
+
+    public override onUpdate(node: AstNode): void {
+        global.generatedEs2panda._AstNodeSetOriginalNode(global.context, node.peer, this.originalPeer)
+    }
+
+    public get isExport(): boolean {
+        return global.generatedEs2panda._AstNodeIsExportedConst(global.context, this.peer);
+    }
+
+    public get isDefaultExport(): boolean {
+        return global.generatedEs2panda._AstNodeIsDefaultExportedConst(global.context, this.peer);
+    }
+
+    public get isStatic(): boolean {
+        return global.generatedEs2panda._AstNodeIsStaticConst(global.context, this.peer);
+    }
+    
+    public get startPosition(): SourcePosition {
+        return new SourcePosition(global.generatedEs2panda._AstNodeStartConst(global.context, this.peer));
+    }
+
+    public set startPosition(start: SourcePosition) {
+        global.generatedEs2panda._AstNodeSetStart(global.context, this.peer, start.peer);
+    }
+
+    public get endPosition(): SourcePosition {
+        return new SourcePosition(global.generatedEs2panda._AstNodeEndConst(global.context, this.peer));
+    }
+
+    public set endPosition(end: SourcePosition) {
+        global.generatedEs2panda._AstNodeSetEnd(global.context, this.peer, end.peer);
+    }
 }

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

@@ -16,7 +16,7 @@
 import { ArktsObject } from "./ArktsObject"
 import { global } from "../static/global"
 import { passStringArray } from "../utilities/private"
-import { KNativePointer } from "@koalaui/interop"
+import { KNativePointer, nullptr } from "@koalaui/interop"
 
 export class Config extends ArktsObject {
     constructor(peer: KNativePointer) {
@@ -48,5 +48,12 @@ export class Config extends ArktsObject {
         )
     }
 
+    destroy() {
+        if (this.peer != nullptr) {
+            global.es2panda._DestroyConfig(this.peer)
+            this.peer = nullptr
+        }
+    }
+
     readonly path: string
 }

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

@@ -14,11 +14,11 @@
  */
 
 import { ArktsObject } from "./ArktsObject"
-import { Program } from "./Program"
+import { Program } from "../../generated"
 import { global } from "../static/global"
-import { throwError } from "../../utils"
-import { passString } from "../utilities/private"
-import { KNativePointer } from "@koalaui/interop"
+import { passString, passStringArray } from "../utilities/private"
+import { KNativePointer, nullptr } from "@koalaui/interop"
+import { Config } from "./Config"
 
 export class Context extends ArktsObject {
     constructor(peer: KNativePointer) {
@@ -29,7 +29,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(
@@ -40,7 +40,73 @@ export class Context extends ArktsObject {
         )
     }
 
+    static createFromFile(filePath: string, configPath: string, stdlibPath: string, outputPath: string): Context | undefined {
+        const config = Config.create([
+            "",
+            "--arktsconfig",
+            configPath,
+            '--extension',
+            'ets',
+            '--stdlib',
+            stdlibPath,
+            filePath,
+            '--output',
+            outputPath,
+        ])
+        return new Context(
+            global.es2panda._CreateContextFromFile(
+                config.peer,
+                passString(filePath)
+            )
+        )
+    }
+
+    static createCacheFromFile(filePath: string, config: Config, globalContext: GlobalContext, isExternal: boolean) {
+        return new Context(
+            global.es2panda._CreateCacheContextFromFile(
+                config.peer,
+                passString(filePath),
+                globalContext.peer,
+                isExternal
+            )
+        )
+    }
+
+
+    destroy() {
+        if (this.peer != nullptr) {
+            global.es2panda._DestroyContext(this.peer)
+            this.peer = nullptr
+        }
+    }
+
     get program(): Program {
         return new Program(global.es2panda._ContextProgram(this.peer));
     }
-}
+}
+
+export class GlobalContext extends ArktsObject {
+    static create(
+        config: Config, externalFileList: string[]
+    ): GlobalContext {
+        return new GlobalContext(
+            global.es2panda._CreateGlobalContext(
+                config.peer,
+                passStringArray(externalFileList),
+                externalFileList.length,
+                false
+            )
+        )
+    }
+
+    constructor(peer: KNativePointer) {
+        super(peer)
+    }
+
+    destroy() {
+        if (this.peer != nullptr) {
+            global.es2panda._DestroyGlobalContext(this.peer)
+            this.peer = nullptr
+        }
+    }
+}

package/build/libarkts-copy/src/arkts-api/peers/{Program.ts → ExternalSource.ts}

@@ -13,29 +13,11 @@
  * limitations under the License.
  */
 
-import { ArktsObject } from "./ArktsObject"
 import { global } from "../static/global"
 import { acceptNativeObjectArrayResult, unpackString } from "../utilities/private"
-import { KNativePointer } from "@koalaui/interop"
-import { ETSModule } from "../../generated"
-
-export class Program extends ArktsObject {
-    constructor(peer: KNativePointer) {
-        super(peer)
-    }
-
-    get astNode(): ETSModule {
-        return new ETSModule(global.es2panda._ProgramAst(global.context, this.peer))
-    }
-
-    get externalSources(): ExternalSource[] {
-        return acceptNativeObjectArrayResult<ExternalSource>(
-            global.es2panda._ProgramExternalSources(global.context, this.peer),
-            (instance: KNativePointer) => new ExternalSource(instance)
-        )
-    }
-
-}
+import { KNativePointer, nullptr } from "@koalaui/interop"
+import { Program } from "../../generated"
+import { ArktsObject } from "./ArktsObject"
 
 export class ExternalSource extends ArktsObject {
     constructor(peer: KNativePointer) {

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

@@ -0,0 +1,34 @@
+/*
+ * 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 { KNativePointer } from "@koalaui/interop"
+import { ArktsObject } from "./ArktsObject"
+import { global } from "../static/global"
+import { Config } from "./Config"
+import { ArkTsConfig } from "../../generated"
+
+export class Options extends ArktsObject {
+    constructor(peer: KNativePointer) {
+        super(peer)
+    }
+
+    static createOptions(config: Config) {
+        return new Options(global.es2panda._ConfigGetOptions(config.peer))
+    }
+
+    getArkTsConfig(): ArkTsConfig {
+        return new ArkTsConfig(global.es2panda._OptionsArkTsConfig(global.context, this.peer))
+    }
+}

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

@@ -0,0 +1,62 @@
+/*
+ * 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 { Program } from "../generated"
+import { ExternalSource } from "./peers/ExternalSource"
+import { programGetExternalSources } from "./node-utilities/Program"
+import { KNativePointer } from "@koalaui/interop"
+import { global } from "./static/global"
+
+export interface CompilationOptions {
+    readonly isMainProgram: boolean,
+    readonly stage: Es2pandaContextState,
+    readonly restart: boolean,
+}
+
+export interface PluginContext {
+    setParameter<V>(name: string, value: V): void
+    parameter<V>(name: string) : V | undefined
+
+}
+export class PluginContextImpl implements PluginContext {
+    map = new Map<String, Object|undefined>()
+    parameter<V>(name: string): V|undefined {
+        return this.map.get(name) as (V|undefined)
+    }
+    setParameter<V>(name: string, value: V) {
+        this.map.set(name, value as Object)
+    }
+}
+
+export type ProgramTransformer = (program: Program, compilationOptions: CompilationOptions, context: PluginContext) => void
+
+export function defaultFilter(name: string) {
+    if (name.startsWith("std.")) return false
+    if (name.startsWith("escompat")) return false
+    return true
+}
+
+export function listPrograms(program: Program, filter: (name: string) => boolean = defaultFilter, context: KNativePointer = global.context): Program[] {
+    return [
+        program,
+        ...programGetExternalSources(program, context).flatMap((it: ExternalSource) => {
+            if (filter(it.getName())) {
+                return it.programs
+            }
+            return []
+        })
+    ]
+}

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

@@ -14,17 +14,18 @@
  */
 
 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 { ArkTsConfig } from "../../generated"
 
 export class global {
     public static filePath: string = "./plugins/input/main.ets"
-    public static packageName: string = ""
-    public static filePathFromPackageRoot: string = global.filePath
+
+    public static arktsconfig?: ArkTsConfig
 
     private static _config?: KNativePointer
     public static set config(config: KNativePointer) {
@@ -34,12 +35,15 @@ 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
+    }
+    public static resetConfig(): void {
+        global._config = undefined
     }
 
     // TODO: rename to contextPeer
     public static get context(): KNativePointer {
-        return global.compilerContext.peer ?? throwError('Global.context not initialized')
+        return global.compilerContext?.peer ?? throwError('Global.context not initialized')
     }
 
     // TODO: rename to context when the pointer valued one is eliminated