@idlizer/arktscgen 2.1.7 → 2.1.9-arktscgen-4

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

@@ -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/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,43 +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
-) {
-    // TODO: check that plugin is on parsed stage
-    const res = unpackNonNullableNode(
-        global.es2panda._ETSParserBuildImportDeclaration(
-            global.context,
-            importKind,
-            passNodeArray(specifiers),
-            specifiers.length,
-            passNode(source),
-            program.peer,
-            flags
-        )
-    )
-    global.es2panda._InsertETSImportDeclarationAndParse(global.context, program.peer, res.peer)
-    // return new ETSImportDeclaration(res.peer)
-    // according to es2panda developers, import declaration is added to ast by compiler
-}
+import { Es2pandaImportKinds } from "../../generated/Es2pandaEnums"
 
 export function updateETSImportDeclaration(
     original: ETSImportDeclaration,
     source: StringLiteral | undefined,
     specifiers: readonly AstNode[],
     importKind: Es2pandaImportKinds
-) {
-    throw new Error("Do not update imports, insert them instead")
+): ETSImportDeclaration {
     if (isSameNativeObject(source, original.source)
         && isSameNativeObject(specifiers, original.specifiers)
         /* no getter for importKind */
@@ -59,11 +32,8 @@ export function updateETSImportDeclaration(
         /* TODO: probably should set importMetadata, but no getter provided yet */
         return original
     }
-    /*
     return updateNodeByNode(
         ETSImportDeclaration.createETSImportDeclaration(source, specifiers, importKind),
         original
     )
-    */
-    return original
 }

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);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/ETSTypeReferencePart.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 { ETSTypeReferencePart, Expression, TSTypeParameterInstantiation } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateETSTypeReferencePart(
+    original: ETSTypeReferencePart,
+    name?: Expression,
+    typeParams?: TSTypeParameterInstantiation,
+    prev?: ETSTypeReferencePart
+): ETSTypeReferencePart {
+    if (
+        isSameNativeObject(name, original.name) &&
+        isSameNativeObject(typeParams, original.typeParams) &&
+        isSameNativeObject(prev, original.previous)
+    ) {
+        return original;
+    }
+
+    const update = updateThenAttach(ETSTypeReferencePart.updateETSTypeReferencePart, attachModifiers);
+    return update(original, name, typeParams, prev);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/ETSUndefinedType.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 { ETSUndefinedType } from '../../generated';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateETSUndefinedType(original: ETSUndefinedType): ETSUndefinedType {
+    /* TODO: no getter provided yet */
+
+    const update = updateThenAttach(ETSUndefinedType.updateETSUndefinedType, attachModifiers);
+    return update(original);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/ETSUnionType.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 { ETSUnionType, TypeNode } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateETSUnionType(original: ETSUnionType, types: readonly TypeNode[]): ETSUnionType {
+    if (isSameNativeObject(types, original.types)) {
+        return original;
+    }
+
+    const update = updateThenAttach(ETSUnionType.updateETSUnionType, attachModifiers);
+    return update(original, types);
+}

package/build/libarkts-copy/src/arkts-api/node-utilities/Identifier.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 { Identifier, TypeNode } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateIdentifier(original: Identifier, name: string, typeAnnotation?: TypeNode): Identifier {
+    if (isSameNativeObject(name, original.name) && isSameNativeObject(typeAnnotation, original.typeAnnotation)) {
+        return original;
+    }
+
+    const update = updateThenAttach(Identifier.update2Identifier, attachModifiers);
+    return update(original, name, typeAnnotation);
+}

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

@@ -0,0 +1,31 @@
+/*
+ * 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 { Identifier, ImportSpecifier } from '../../generated';
+import { isSameNativeObject } from '../peers/ArktsObject';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateImportSpecifier(
+    original: ImportSpecifier,
+    imported?: Identifier,
+    local?: Identifier
+): ImportSpecifier {
+    if (isSameNativeObject(imported, original.imported) && isSameNativeObject(local, original.local)) {
+        return original;
+    }
+
+    const update = updateThenAttach(ImportSpecifier.updateImportSpecifier, attachModifiers);
+    return update(original, imported, local);
+}

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

@@ -25,7 +25,7 @@ export function updateMemberExpression(
     kind: Es2pandaMemberExpressionKind,
     computed: boolean,
     optional_arg: boolean
-) {
+): MemberExpression {
     if (isSameNativeObject(object_arg, original.object)
         && isSameNativeObject(property, original.property)
         && isSameNativeObject(kind, original.kind)

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

@@ -29,7 +29,7 @@ export function createMethodDefinition(
     modifiers: Es2pandaModifierFlags,
     isComputed: boolean,
     overloads?: readonly MethodDefinition[]
-) {
+): MethodDefinition {
     const res = MethodDefinition.createMethodDefinition(
         kind,
         key,
@@ -51,7 +51,7 @@ export function updateMethodDefinition(
     modifiers: Es2pandaModifierFlags,
     isComputed: boolean,
     overloads?: readonly MethodDefinition[]
-) {
+): MethodDefinition {
     if (isSameNativeObject(kind, original.kind)
         && isSameNativeObject(key, original.key)
         && isSameNativeObject(value, original.value)

package/build/libarkts-copy/src/arkts-api/node-utilities/NullLiteral.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 { NullLiteral } from '../../generated';
+import { attachModifiers, updateThenAttach } from '../utilities/private';
+
+export function updateNullLiteral(original: NullLiteral): NullLiteral {
+    /* TODO: no getter provided yet */
+
+    const update = updateThenAttach(NullLiteral.updateNullLiteral, attachModifiers);
+    return update(original);
+}

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

@@ -20,7 +20,7 @@ import { updateNodeByNode } from "../utilities/private"
 
 export function createNumberLiteral(
     value: number
-) {
+): NumberLiteral {
     return new NumberLiteral(
         global.es2panda._CreateNumberLiteral(
             global.context,
@@ -32,7 +32,7 @@ export function createNumberLiteral(
 export function updateNumberLiteral(
     original: NumberLiteral,
     value: number
-) {
+): NumberLiteral {
     if (isSameNativeObject(value.toString(), original.str)) {
         return original
     }