@idlizer/arktscgen 2.1.5 → 2.1.9-arktscgen-4

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/AnnotationDeclaration.ts

@@ -0,0 +1,32 @@
+/*
+ * 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 { AnnotationDeclaration, Expression } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+import { AstNode } from '../peers/AstNode';
+
+export function updateAnnotationDeclaration(
+    original: AnnotationDeclaration,
+    expr: Expression | undefined,
+    properties: readonly AstNode[]
+): AnnotationDeclaration {
+    if (isSameNativeObject(expr, original.expr) && isSameNativeObject(properties, original.properties)) {
+        return original;
+    }
+
+    const update = updateThenAttach(AnnotationDeclaration.update1AnnotationDeclaration, attachModifiers);
+    return update(original, expr, properties);
+}

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

@@ -0,0 +1,37 @@
+/*
+ * 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';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+import { AstNode } from '../peers/AstNode';
+
+export function updateAnnotationUsage(original: AnnotationUsage, expr?: Expression): AnnotationUsage {
+    if (isSameNativeObject(expr, original.expr)) {
+        return original;
+    }
+
+    const update = updateThenAttach(AnnotationUsage.updateAnnotationUsage, attachModifiers);
+    return update(original, expr);
+}
+
+export function update1AnnotationUsage(original: AnnotationUsage, expr: Expression | undefined, properties: readonly AstNode[]): AnnotationUsage {
+    if (isSameNativeObject(expr, original.expr) && isSameNativeObject(properties, original.properties)) {
+        return original;
+    }
+
+    const update = updateThenAttach(AnnotationUsage.update1AnnotationUsage, attachModifiers);
+    return update(original, expr, properties);
+}

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

@@ -0,0 +1,26 @@
+/*
+ * 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(`\tEntry:            ${arkTsConfig.entry}`)
+    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/BinaryExpression.ts

@@ -0,0 +1,37 @@
+/*
+ * 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 { BinaryExpression, Expression } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+import { Es2pandaTokenType } from '../../generated/Es2pandaEnums';
+
+export function updateBinaryExpression(
+    original: BinaryExpression,
+    left: Expression | undefined,
+    right: Expression | undefined,
+    operatorType: Es2pandaTokenType
+): BinaryExpression {
+    if (
+        isSameNativeObject(left, original.left) &&
+        isSameNativeObject(right, original.right) &&
+        isSameNativeObject(operatorType, original.operatorType)
+    ) {
+        return original;
+    }
+
+    const update = updateThenAttach(BinaryExpression.updateBinaryExpression, attachModifiers);
+    return update(original, left, right, operatorType);
+}

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

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

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/ChainExpression.ts

@@ -0,0 +1,27 @@
+/*
+ * 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 { ChainExpression, Expression } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateChainExpression(original: ChainExpression, expression?: Expression): ChainExpression {
+    if (isSameNativeObject(expression, original.expression)) {
+        return original;
+    }
+
+    const update = updateThenAttach(ChainExpression.updateChainExpression, attachModifiers);
+    return update(original, expression);
+}

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

@@ -13,29 +13,52 @@
  * limitations under the License.
  */
 
-import { ClassProperty, Expression, TypeNode } from "../../generated"
+import { AnnotationUsage, ClassProperty, Expression, TypeNode } from "../../generated"
 import { Es2pandaModifierFlags } from "../../generated/Es2pandaEnums"
 import { isSameNativeObject } from "../peers/ArktsObject"
 import { updateNodeByNode } from "../utilities/private"
 
+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,
+        typeAnnotation,
+        modifiers,
+        isComputed,
+    )
+    if (annotations) {
+        res.setAnnotations(annotations)
+    }
+    return res
+}
+
 export function updateClassProperty(
     original: ClassProperty,
     key: Expression | undefined,
     value: Expression | undefined,
     typeAnnotation: TypeNode | undefined,
     modifiers: Es2pandaModifierFlags,
-    isComputed: boolean
-) {
+    isComputed: boolean,
+    annotations?: readonly AnnotationUsage[],
+): ClassProperty {
     if (isSameNativeObject(key, original.key)
         && isSameNativeObject(value, original.value)
         && isSameNativeObject(typeAnnotation, original.typeAnnotation)
         && isSameNativeObject(modifiers, original.modifierFlags)
         && isSameNativeObject(isComputed, original.isComputed)
+        && isSameNativeObject(annotations, original.annotations)
     ) {
         return original
     }
     return updateNodeByNode(
-        ClassProperty.createClassProperty(key, value, typeAnnotation, modifiers, isComputed),
+        createClassProperty(key, value, typeAnnotation, modifiers, isComputed, annotations),
         original
     )
 }

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

@@ -0,0 +1,36 @@
+/*
+ * 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 { ConditionalExpression, Expression } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateConditionalExpression(
+    original: ConditionalExpression,
+    test?: Expression,
+    consequent?: Expression,
+    alternate?: Expression
+): ConditionalExpression {
+    if (
+        isSameNativeObject(test, original.test) &&
+        isSameNativeObject(consequent, original.consequent) &&
+        isSameNativeObject(alternate, original.alternate)
+    ) {
+        return original;
+    }
+
+    const update = updateThenAttach(ConditionalExpression.updateConditionalExpression, attachModifiers);
+    return update(original, test, consequent, alternate);
+}

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)

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

@@ -15,40 +15,16 @@
 
 import { ETSImportDeclaration, StringLiteral } from "../../generated"
 import { isSameNativeObject } from "../peers/ArktsObject"
-import { passNode, passNodeArray, unpackNonNullableNode, updateNodeByNode } from "../utilities/private"
+import { updateNodeByNode } from "../utilities/private"
 import { AstNode } from "../peers/AstNode"
-import { Es2pandaImportFlags, Es2pandaImportKinds } from "../../generated/Es2pandaEnums"
-import { global } from "../static/global"
-import { Program } from "../peers/Program"
-
-export function createETSImportDeclaration(
-    source: StringLiteral | undefined,
-    specifiers: readonly AstNode[],
-    importKind: Es2pandaImportKinds,
-    program: Program,
-    flags: Es2pandaImportFlags
-): ETSImportDeclaration {
-    const res = unpackNonNullableNode(
-        global.es2panda._ETSParserBuildImportDeclaration(
-            global.context,
-            importKind,
-            passNodeArray(specifiers),
-            specifiers.length,
-            passNode(source),
-            program.peer,
-            flags
-        )
-    )
-    global.es2panda._InsertETSImportDeclarationAndParse(global.context, global.compilerContext.program.peer, res.peer)
-    return new ETSImportDeclaration(res.peer)
-}
+import { Es2pandaImportKinds } from "../../generated/Es2pandaEnums"
 
 export function updateETSImportDeclaration(
     original: ETSImportDeclaration,
     source: StringLiteral | undefined,
     specifiers: readonly AstNode[],
     importKind: Es2pandaImportKinds
-) {
+): ETSImportDeclaration {
     if (isSameNativeObject(source, original.source)
         && isSameNativeObject(specifiers, original.specifiers)
         /* no getter for importKind */

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

@@ -0,0 +1,34 @@
+/*
+ * 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 { ETSNewClassInstanceExpression, Expression } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateETSNewClassInstanceExpression(
+    original: ETSNewClassInstanceExpression,
+    typeReference: Expression | undefined,
+    _arguments: readonly Expression[]
+): ETSNewClassInstanceExpression {
+    if (
+        isSameNativeObject(typeReference, original.typeRef) &&
+        isSameNativeObject(_arguments, original.arguments)
+    ) {
+        return original;
+    }
+
+    const update = updateThenAttach(ETSNewClassInstanceExpression.updateETSNewClassInstanceExpression, attachModifiers);
+    return update(original, typeReference, _arguments);
+}

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

@@ -21,16 +21,12 @@ export function createETSParameterExpression(
     identOrSpread: AnnotatedExpression | undefined,
     isOptional: boolean,
     initExpr?: Expression,
-    typeAnnotation?: TypeNode,
     annotations?: readonly AnnotationUsage[]
-) {
+): ETSParameterExpression {
     const res = ETSParameterExpression.createETSParameterExpression(identOrSpread, isOptional)
     if (initExpr) {
         res.setInitializer(initExpr)
     }
-    if (typeAnnotation) {
-        res.setTypeAnnotation(typeAnnotation)
-    }
     if (annotations) {
         res.setAnnotations(annotations)
     }
@@ -42,19 +38,17 @@ export function updateETSParameterExpression(
     identOrSpread: AnnotatedExpression | undefined,
     isOptional: boolean,
     initExpr?: Expression,
-    typeAnnotation?: TypeNode,
     annotations?: readonly AnnotationUsage[],
-) {
+): ETSParameterExpression {
     if ((isSameNativeObject(identOrSpread, original.ident) || isSameNativeObject(identOrSpread, original.restParameter))
         && isSameNativeObject(isOptional, original.isOptional)
         && isSameNativeObject(initExpr, original.initializer)
-        && isSameNativeObject(typeAnnotation, original.typeAnnotation)
         && isSameNativeObject(annotations, original.annotations)
     ) {
         return original
     }
     return updateNodeByNode(
-        createETSParameterExpression(identOrSpread, isOptional, initExpr, typeAnnotation, annotations),
+        createETSParameterExpression(identOrSpread, isOptional, initExpr, annotations),
         original
     )
 }

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

@@ -0,0 +1,28 @@
+/*
+ * 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 { ETSPrimitiveType } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+import { Es2pandaPrimitiveType } from '../../generated/Es2pandaEnums';
+
+export function updateETSPrimitiveType(original: ETSPrimitiveType, type: Es2pandaPrimitiveType): ETSPrimitiveType {
+    if (isSameNativeObject(type, original.primitiveType)) {
+        return original;
+    }
+
+    const update = updateThenAttach(ETSPrimitiveType.updateETSPrimitiveType, attachModifiers);
+    return update(original, type);
+}

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

@@ -20,7 +20,7 @@ import { updateNodeByNode } from "../utilities/private"
 export function updateETSStructDeclaration(
     original: ETSStructDeclaration,
     def?: ClassDefinition
-) {
+): ETSStructDeclaration {
     if (isSameNativeObject(def, original.definition)) {
         return original
     }

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

@@ -20,7 +20,7 @@ import { updateNodeByNode } from "../utilities/private"
 export function updateETSTuple(
     original: ETSTuple,
     typeList: readonly TypeNode[]
-) {
+): ETSTuple {
     if (isSameNativeObject(typeList, original.tupleTypeAnnotationsList)) {
         return original
     }

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

@@ -0,0 +1,27 @@
+/*
+ * 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 { ETSTypeReference, ETSTypeReferencePart } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateETSTypeReference(original: ETSTypeReference, part?: ETSTypeReferencePart): ETSTypeReference {
+    if (isSameNativeObject(part, original.part)) {
+        return original;
+    }
+
+    const update = updateThenAttach(ETSTypeReference.updateETSTypeReference, attachModifiers);
+    return update(original, part);
+}