@idlizer/arktscgen 2.1.7 → 2.1.9-arktscgen-5

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

@@ -0,0 +1,78 @@
+/*
+ * 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 { ETSModule, ImportDeclaration, isETSImportDeclaration, Program, Statement } from "../generated"
+import { updateETSModuleByStatements } from "./utilities/public"
+import { passNode, passNodeArray, unpackNonNullableNode } from "./utilities/private"
+import { global } from "./static/global"
+import { Es2pandaImportFlags, Es2pandaImportKinds } from "../generated/Es2pandaEnums"
+
+export class ImportStorage {
+    // TODO: migrate to wrappers instead of pointers
+    private imports: Set<KNativePointer> = new Set<KNativePointer>()
+    private importSources: Set<string | undefined> = new Set<string | undefined>()
+
+    constructor(private program: Program, private isParserStage: boolean) {
+        for (const statement of program.ast.statements) {
+            if (isETSImportDeclaration(statement)) {
+                this.imports.add(statement.peer)
+                if (!isParserStage) {
+                    // TODO: is source non nullable?
+                    this.importSources.add(statement.source?.str)
+                }
+            }
+        }
+    }
+
+    update() {
+        // Save current statements
+        const statements = this.program.ast.statements
+
+        // Update parser information
+        const newStatements: Statement[] = []
+        for (const statement of statements) {
+            if (isETSImportDeclaration(statement) && !this.imports.has(statement.peer)) {
+                if (!this.isParserStage && !this.importSources.has(statement.source?.str)) {
+                    console.warn("Attempt to insert import from new source after parsed stage:")
+                    console.warn(statement.dumpSrc())
+                }
+
+                const importDeclaration = unpackNonNullableNode<ImportDeclaration>(
+                    // Note: this call is important, we cannot just pass "statement" to "InsertETSImportDeclarationAndParse"
+                    global.es2panda._ETSParserBuildImportDeclaration(
+                        global.context,
+                        Es2pandaImportKinds.IMPORT_KINDS_ALL, // TODO: do we use IMPORT_KINDS_TYPES?
+                        passNodeArray(statement.specifiers),
+                        statement.specifiers.length,
+                        passNode(statement.source),
+                        this.program.peer,
+                        Es2pandaImportFlags.IMPORT_FLAGS_NONE, // TODO: where to get it?
+                    )
+                )
+                global.es2panda._InsertETSImportDeclarationAndParse(global.context, this.program.peer, importDeclaration.peer)
+                newStatements.push(importDeclaration)
+            } else {
+                newStatements.push(statement)
+            }
+        }
+
+        // Drop import statements generated by compiler in the beginning of the ETSModule
+        updateETSModuleByStatements(
+            this.program.ast as ETSModule,
+            newStatements,
+        )
+    }
+}

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

@@ -0,0 +1,89 @@
+/*
+ * 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.
+ */
+
+import { factory } from "./factory/nodeFactory"
+import { isReturnStatement, isScriptFunction, ScriptFunction } from "../generated"
+import { AbstractVisitor } from "./AbstractVisitor"
+import { AstNode } from "./peers/AstNode"
+import { Es2pandaPrimitiveType, Es2pandaScriptFunctionFlags } from "src/generated/Es2pandaEnums"
+
+interface IsScriptFunctionRoot {
+    isScriptFunctionRoot: boolean
+}
+
+// TODO: this is to workaround compiler not beeing able to infer return type on recheck
+class CheckReturns extends AbstractVisitor {
+    visitor(node: AstNode, options?: IsScriptFunctionRoot): AstNode {
+        if (isReturnStatement(node) && node.argument !== undefined) {
+            this.seenNonVoidReturn = true
+        }
+        if (isScriptFunction(node) && !options?.isScriptFunctionRoot) {
+            return node
+        }
+        return this.visitEachChild(node)
+    }
+
+    seenNonVoidReturn: boolean = false
+    static instance?: CheckReturns
+}
+
+// This function checks that it is possible to infer return type of script function as void
+function checkReturns(node: AstNode): boolean {
+    if (!CheckReturns.instance) {
+        CheckReturns.instance = new CheckReturns()
+    }
+    CheckReturns.instance.seenNonVoidReturn = false
+    CheckReturns.instance.visitor(node, { isScriptFunctionRoot: true })
+    return CheckReturns.instance.seenNonVoidReturn == false
+}
+
+class InferVoidReturnType extends AbstractVisitor {
+    visitor(node: AstNode): AstNode {
+        const result = this.visitEachChild(node)
+        if (isScriptFunction(result) &&
+            result.returnTypeAnnotation === undefined &&
+            !result.isConstructor && // constructors should not have return type
+            (result.flags & Es2pandaScriptFunctionFlags.SCRIPT_FUNCTION_FLAGS_SETTER) == 0 // setters should not return void
+        ) {
+            const isVoid = checkReturns(result)
+            if (isVoid) {
+                return factory.updateScriptFunction(
+                    result,
+                    result.body,
+                    result.typeParams,
+                    result.params,
+                    factory.createETSPrimitiveType(
+                        Es2pandaPrimitiveType.PRIMITIVE_TYPE_VOID,
+                    ),
+                    result.hasReceiver,
+                    result.flags,
+                    result.modifierFlags,
+                    result.id,
+                    result.annotations,
+                )
+            }
+        }
+        return result
+    }
+
+    static instance?: InferVoidReturnType
+}
+
+export function inferVoidReturnType(node: AstNode) {
+    if (!InferVoidReturnType.instance) {
+        InferVoidReturnType.instance = new InferVoidReturnType()
+    }
+    InferVoidReturnType.instance.visitor(node)
+}

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

@@ -0,0 +1,50 @@
+/*
+ * 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 { defaultFilter, listPrograms } from "./plugins"
+import { Program } from "../generated"
+
+export class ProgramProvider {
+    // TODO: migrate to wrappers instead of pointers
+    seenPrograms: Set<KNativePointer> = new Set<KNativePointer>()
+    queue: Program[] = []
+
+    constructor(private mainProgram: Program, private readonly filter: (name: string) => boolean = defaultFilter) {
+        this.seenPrograms.add(mainProgram.peer)
+        this.queue = [mainProgram]
+    }
+
+    updateQueue() {
+        const listed = listPrograms(this.mainProgram, this.filter)
+        for (const program of listed) {
+            if (!this.seenPrograms.has(program.peer)) {
+                this.seenPrograms.add(program.peer)
+                this.queue.push(program)
+            }
+        }
+    }
+
+    next(): Program | undefined {
+        if (this.queue.length == 0) {
+            this.updateQueue()
+            if (this.queue.length == 0) {
+                // console.log("PROGRAMS:", this.seenPrograms.size)
+                return undefined
+            }
+        }
+        return this.queue.shift()
+    }
+}

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

@@ -14,38 +14,31 @@
  */
 
 import { factory } from "./factory/nodeFactory"
-import { ETSModule, isMethodDefinition, MethodDefinition } from "../generated"
+import { isMethodDefinition } from "../generated"
 import { AbstractVisitor } from "./AbstractVisitor"
 import { AstNode } from "./peers/AstNode"
 
 export class SetBaseOverloads extends AbstractVisitor {
-    visitor(node: MethodDefinition, baseOverloadMethod?: MethodDefinition): MethodDefinition
-    visitor(node: AstNode, baseOverloadMethod?: MethodDefinition): AstNode
-    visitor(node: AstNode, baseOverloadMethod?: MethodDefinition): AstNode {
+    visitor(node: AstNode): AstNode {
         if (isMethodDefinition(node)) {
-            const result = factory.updateMethodDefinition(
+            const baseOverloadMethod = node
+            return factory.updateMethodDefinition(
                 node,
                 node.kind,
                 node.key,
                 node.value,
                 node.modifierFlags,
                 node.isComputed,
-                node.overloads.map((it) => this.visitor(it, node)),
+                node.overloads.map((it) => {
+                    it.setBaseOverloadMethod(baseOverloadMethod)
+                    return it
+                })
             )
-            if (baseOverloadMethod) {
-                result.setBaseOverloadMethod(baseOverloadMethod)
-            }
-            return result
         }
         return this.visitEachChild(node)
     }
-
-    static instance?: SetBaseOverloads
 }
 
-export function setBaseOverloads(node: ETSModule) {
-    if (!SetBaseOverloads.instance) {
-        SetBaseOverloads.instance = new SetBaseOverloads()
-    }
-    SetBaseOverloads.instance.visitor(node)
+export function setBaseOverloads(node: AstNode) {
+    new SetBaseOverloads().visitor(node)
 }

package/build/libarkts-copy/src/arkts-api/class-by-peer.ts

@@ -18,8 +18,7 @@ import { throwError } from "../utils"
 import { global } from "./static/global"
 import { KNativePointer, nullptr } from "@koalaui/interop"
 import { AstNode } from "./peers/AstNode"
-import { factory } from "@koalaui/ets-tsc"
-import { unpackString } from "./utilities/private"
+import { NodeCache } from "./node-cache"
 
 export const nodeByType = new Map<Es2pandaAstNodeType, (peer: KNativePointer) => AstNode>([])
 
@@ -29,5 +28,5 @@ export function classByPeer<T extends AstNode>(peer: KNativePointer): T {
     }
     const type = global.generatedEs2panda._AstNodeTypeConst(global.context, peer)
     const create = nodeByType.get(type) ?? throwError(`unknown node type: ${type}`)
-    return create(peer) as T
+    return NodeCache.cached(peer, create)
 }

package/build/libarkts-copy/src/arkts-api/factory/nodeFactory.ts

@@ -15,16 +15,15 @@
 
 import {
     ClassDefinition,
-    ClassProperty,
+    ETSImportDeclaration,
     ETSStructDeclaration,
+    ETSTuple,
     ETSTypeReferencePart,
     MemberExpression,
+    ObjectExpression,
     TryStatement,
-    TSInterfaceDeclaration,
     TSTypeParameter,
     VariableDeclarator,
-    ObjectExpression,
-    ETSTuple,
 } from "../../generated"
 import { factory as generatedFactory } from "../../generated/factory"
 import { createScriptFunction, updateScriptFunction } from "../node-utilities/ScriptFunction"
@@ -34,7 +33,7 @@ import { updateMemberExpression } from "../node-utilities/MemberExpression"
 import { createETSParameterExpression, updateETSParameterExpression } from "../node-utilities/ETSParameterExpression"
 import { updateTSTypeParameter } from "../node-utilities/TSTypeParameter"
 import { updateETSTypeReferencePart } from "../node-utilities/TSTypeReferencePart"
-import { createETSImportDeclaration, updateETSImportDeclaration } from "../node-utilities/ETSImportDeclaration"
+import { updateETSImportDeclaration } from "../node-utilities/ETSImportDeclaration"
 import { updateVariableDeclarator } from "../node-utilities/VariableDeclarator"
 import { updateClassDefinition } from "../node-utilities/ClassDefinition"
 import { updateETSStructDeclaration } from "../node-utilities/ETSStructDeclaration"
@@ -50,6 +49,9 @@ import { updateObjectExpression } from "../node-utilities/ObjectExpression"
 import { updateETSTuple } from "../node-utilities/ETSTuple"
 import { createArrayExpression, updateArrayExpression } from "../node-utilities/ArrayExpression"
 import { createTSTypeAliasDeclaration, updateTSTypeAliasDeclaration } from "../node-utilities/TSTypeAliasDeclaration"
+import { createClassDeclaration, updateClassDeclaration } from "../node-utilities/ClassDeclaration"
+import { createBlockStatement, updateBlockStatement } from "../node-utilities/BlockStatement"
+import { updateAnnotationUsage } from "../node-utilities/AnnotationUsage"
 
 export const factory = {
     ...generatedFactory,
@@ -75,7 +77,7 @@ export const factory = {
     createETSTypeReferencePart: ETSTypeReferencePart.createETSTypeReferencePart,
     updateETSTypeReferencePart,
 
-    createETSImportDeclaration,
+    createETSImportDeclaration: ETSImportDeclaration.createETSImportDeclaration,
     updateETSImportDeclaration,
 
     createVariableDeclarator: VariableDeclarator.create1VariableDeclarator,
@@ -90,6 +92,9 @@ export const factory = {
     createClassDefinition: ClassDefinition.createClassDefinition,
     updateClassDefinition,
 
+    createClassDeclaration,
+    updateClassDeclaration,
+
     createClassProperty,
     updateClassProperty,
 
@@ -122,4 +127,11 @@ export const factory = {
 
     createTSTypeAliasDeclaration,
     updateTSTypeAliasDeclaration,
+
+    createBlockStatement,
+    updateBlockStatement,
+
+    updateAnnotationUsage,
+    update1AnnotationUsage: generatedFactory.updateAnnotationUsage,
+    updateInterfaceBody : generatedFactory.updateTSInterfaceBody
 }

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

@@ -21,13 +21,22 @@ export * from "./utilities/public"
 export * from "./factory/nodeFactory"
 export * from "./visitor"
 export * from "./AbstractVisitor"
+export * from "./ChainExpressionFilter"
 export * from "./CheckedBackFilter"
 export * from "./SetBaseOverloads"
 export * from "./plugins"
+export * from "./ImportStorage"
+export * from "./InferVoidReturnType"
+export * from "./ProgramProvider"
+export * from "./CompileWithCache"
 
 export * from "./peers/AstNode"
 export * from "./peers/Config"
 export * from "./peers/Context"
-export * from "./peers/Program"
+export * from "./peers/ExternalSource"
+export * from "./peers/Options"
+export * from "./node-utilities/ArkTsConfig"
+export * from "./node-utilities/Program"
 export * from "./peers/ImportPathManager"
 export { global as arktsGlobal } from "./static/global"
+export * from "./wrapper-compat"

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

@@ -13,22 +13,26 @@
  * limitations under the License.
  */
 
-import { ArktsObject } from "./peers/ArktsObject"
 import { KNativePointer } from "@koalaui/interop"
+import { AstNode } from "./peers/AstNode"
 
 export class NodeCache {
-    private static cache = new Map<KNativePointer, ArktsObject>()
+    private static cache = new Map<KNativePointer, AstNode>()
 
-    static cached<T extends ArktsObject>(pointer: KNativePointer, factory: (pointer: KNativePointer) => ArktsObject): T {
+    static cached<T extends AstNode>(pointer: KNativePointer, factory: (pointer: KNativePointer) => AstNode): T {
         const cached = NodeCache.cache.get(pointer)
         if (cached !== undefined) {
             return cached as T
         }
         const node = factory(pointer)
-        NodeCache.cache.set(pointer, node)
+        NodeCache.addToCache(pointer, node)
         return node as T
     }
 
+    public static addToCache(pointer: KNativePointer, node: AstNode) {
+        NodeCache.cache.set(pointer, node)
+    }
+
     public static clear(): void {
         NodeCache.cache.clear()
     }

package/build/libarkts-copy/src/arkts-api/node-utilities/AnnotationUsage.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 { AnnotationUsage, Expression } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+
+// TODO generate this function
+export function updateAnnotationUsage(original: AnnotationUsage, expr?: Expression): AnnotationUsage {
+    if (isSameNativeObject(expr, original.expr)) {
+        return original;
+    }
+
+    const newNode = AnnotationUsage.updateAnnotationUsage(original, expr);
+    original.onUpdate(newNode)
+    return newNode
+}
+

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

@@ -0,0 +1,25 @@
+/*
+ * 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 { ArkTsConfig } from "../../generated"
+
+export function dumpArkTsConfigInfo(arkTsConfig: ArkTsConfig) {
+    console.log(`ArkTsConfig info:`)
+    console.log(`\tBaseUrl:          ${arkTsConfig.baseUrl}`)
+    console.log(`\tConfigPath:       ${arkTsConfig.configPath}`)
+    console.log(`\tOutDir:           ${arkTsConfig.outDir}`)
+    console.log(`\tPackage:          ${arkTsConfig.package}`)
+    console.log(`\tRootDir:          ${arkTsConfig.rootDir}`)
+}

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

@@ -16,7 +16,7 @@
 import { Es2pandaAstNodeType } from "../../generated/Es2pandaEnums"
 import { ArrayExpression, Expression } from "../../generated"
 import { isSameNativeObject } from "../peers/ArktsObject"
-import { updateNodeByNode } from "../../reexport-for-generated"
+import { updateNodeByNode } from "../utilities/private"
 
 export function createArrayExpression(
     elements: readonly Expression[]

package/build/libarkts-copy/src/arkts-api/node-utilities/BlockStatement.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 { BlockStatement, Statement } from "../../generated"
+import { isSameNativeObject } from "../peers/ArktsObject"
+import { updateNodeByNode } from "../utilities/private"
+
+export function createBlockStatement(statements: readonly Statement[]): BlockStatement {
+    return BlockStatement.createBlockStatement(statements)
+}
+
+export function updateBlockStatement(original: BlockStatement, statements: readonly Statement[]): BlockStatement {
+    if (isSameNativeObject(statements, original.statements)) {
+        return original
+    }
+    return updateNodeByNode(BlockStatement.createBlockStatement(statements), original)
+}

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

@@ -24,7 +24,7 @@ export function createCallExpression(
     optional_arg: boolean = false,
     trailingComma: boolean = false,
     trailingBlock: BlockStatement | undefined = undefined,
-) {
+): CallExpression {
     const res = CallExpression.createCallExpression(
         callee,
         _arguments,
@@ -46,7 +46,7 @@ export function updateCallExpression(
     optional_arg: boolean = false,
     trailingComma: boolean = false,
     trailingBlock: BlockStatement | undefined = undefined,
-) {
+): CallExpression {
     if (isSameNativeObject(callee, original.callee)
         && isSameNativeObject(_arguments, original.arguments)
         && isSameNativeObject(typeParams, original.typeParams)

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

@@ -0,0 +1,54 @@
+/*
+ * 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 {
+    ClassDeclaration,
+    ClassDefinition,
+} from "../../generated"
+import { isSameNativeObject } from "../peers/ArktsObject"
+import { updateNodeByNode } from "../utilities/private"
+import { Es2pandaModifierFlags } from "../../generated/Es2pandaEnums"
+
+export function createClassDeclaration(
+    def?: ClassDefinition,
+    modifierFlags?: Es2pandaModifierFlags,
+): ClassDeclaration {
+    const res = ClassDeclaration.createClassDeclaration(
+        def,
+    )
+    if (modifierFlags) {
+        res.modifierFlags = modifierFlags
+    }
+    return res
+}
+
+export function updateClassDeclaration(
+    original: ClassDeclaration,
+    def?: ClassDefinition,
+    modifierFlags?: Es2pandaModifierFlags,
+): ClassDeclaration {
+    if (isSameNativeObject(def, original.definition)
+        && isSameNativeObject(modifierFlags, original.modifierFlags)
+    ) {
+        return original
+    }
+    return updateNodeByNode(
+        createClassDeclaration(
+            def,
+            modifierFlags,
+        ),
+        original
+    )
+}

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

@@ -40,7 +40,7 @@ export function updateClassDefinition(
     body: readonly AstNode[],
     modifiers: Es2pandaClassDefinitionModifiers,
     flags: Es2pandaModifierFlags
-) {
+): ClassDefinition {
     if (original.ctor !== undefined && !isMethodDefinition(original.ctor)) {
         throwError(`class definition constructor is not method definition: ${ctor?.dump()}`)
     }

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

@@ -18,14 +18,14 @@ import { Es2pandaModifierFlags } from "../../generated/Es2pandaEnums"
 import { isSameNativeObject } from "../peers/ArktsObject"
 import { updateNodeByNode } from "../utilities/private"
 
-export function createClassProperty(    
+export function createClassProperty(
     key: Expression | undefined,
     value: Expression | undefined,
     typeAnnotation: TypeNode | undefined,
     modifiers: Es2pandaModifierFlags,
     isComputed: boolean,
     annotations?: readonly AnnotationUsage[],
-) {
+): ClassProperty {
     const res = ClassProperty.createClassProperty(
         key,
         value,
@@ -47,7 +47,7 @@ export function updateClassProperty(
     modifiers: Es2pandaModifierFlags,
     isComputed: boolean,
     annotations?: readonly AnnotationUsage[],
-) {
+): ClassProperty {
     if (isSameNativeObject(key, original.key)
         && isSameNativeObject(value, original.value)
         && isSameNativeObject(typeAnnotation, original.typeAnnotation)

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

@@ -25,7 +25,7 @@ export function createETSFunctionType(
     hasReceiver: boolean,
     funcFlags: Es2pandaScriptFunctionFlags,
     annotations?: readonly AnnotationUsage[],
-) {
+): ETSFunctionType {
     const res = ETSFunctionType.createETSFunctionType(
         FunctionSignature.createFunctionSignature(
             typeParams,
@@ -49,7 +49,7 @@ export function updateETSFunctionType(
     hasReceiver: boolean,
     funcFlags: Es2pandaScriptFunctionFlags,
     annotations?: readonly AnnotationUsage[],
-) {
+): ETSFunctionType {
     if (isSameNativeObject(typeParams, original.typeParams)
         && isSameNativeObject(params, original.params)
         && isSameNativeObject(returnTypeAnnotation, original.returnType)