@idlizer/arktscgen 2.1.7 → 2.1.9-arktscgen-4

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,33 @@ 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 { updateAnnotationDeclaration } from "../node-utilities/AnnotationDeclaration"
+import { updateAnnotationUsage, update1AnnotationUsage } from "../node-utilities/AnnotationUsage"
+import { updateBinaryExpression } from "../node-utilities/BinaryExpression"
+import { updateBlockExpression } from "../node-utilities/BlockExpression"
+import { updateChainExpression } from "../node-utilities/ChainExpression"
+import { updateConditionalExpression } from "../node-utilities/ConditionalExpression"
+import { updateETSPrimitiveType } from "../node-utilities/ETSPrimitiveType"
+import { updateETSTypeReference } from "../node-utilities/ETSTypeReference"
+import { updateETSUndefinedType } from "../node-utilities/ETSUndefinedType"
+import { updateETSUnionType } from "../node-utilities/ETSUnionType"
+import { updateIdentifier } from "../node-utilities/Identifier"
+import { updateImportSpecifier } from "../node-utilities/ImportSpecifier"
+import { updateNullLiteral } from "../node-utilities/NullLiteral"
+import { updateReturnStatement } from "../node-utilities/ReturnStatement"
+import { updateStringLiteral } from "../node-utilities/StringLiteral"
+import { updateSuperExpression } from "../node-utilities/SuperExpression"
+import { updateTSAsExpression } from "../node-utilities/TSAsExpression"
+import { updateTSClassImplements } from "../node-utilities/TSClassImplements"
+import { updateTSInterfaceBody } from "../node-utilities/TSInterfaceBody"
+import { updateTSNonNullExpression } from "../node-utilities/TSNonNullExpression"
+import { updateTSTypeParameterDeclaration } from "../node-utilities/TSTypeParameterDeclaration"
+import { updateTSTypeParameterInstantiation } from "../node-utilities/TSTypeParameterInstantiation"
+import { updateTemplateLiteral } from "../node-utilities/TemplateLiteral"
+import { updateThisExpression } from "../node-utilities/ThisExpression"
+import { updateUndefinedLiteral } from "../node-utilities/UndefinedLiteral"
 
 export const factory = {
     ...generatedFactory,
@@ -75,7 +101,7 @@ export const factory = {
     createETSTypeReferencePart: ETSTypeReferencePart.createETSTypeReferencePart,
     updateETSTypeReferencePart,
 
-    createETSImportDeclaration,
+    createETSImportDeclaration: ETSImportDeclaration.createETSImportDeclaration,
     updateETSImportDeclaration,
 
     createVariableDeclarator: VariableDeclarator.create1VariableDeclarator,
@@ -90,6 +116,9 @@ export const factory = {
     createClassDefinition: ClassDefinition.createClassDefinition,
     updateClassDefinition,
 
+    createClassDeclaration,
+    updateClassDeclaration,
+
     createClassProperty,
     updateClassProperty,
 
@@ -122,4 +151,58 @@ export const factory = {
 
     createTSTypeAliasDeclaration,
     updateTSTypeAliasDeclaration,
+
+    createBlockStatement,
+    updateBlockStatement,
+
+    updateAnnotationDeclaration,
+
+    updateAnnotationUsage,
+    update1AnnotationUsage,
+
+    updateBinaryExpression,
+
+    updateBlockExpression,
+
+    updateChainExpression,
+
+    updateConditionalExpression,
+
+    updateETSPrimitiveType,
+
+    updateETSTypeReference,
+
+    updateETSUndefinedType,
+
+    updateETSUnionType,
+
+    updateIdentifier,
+
+    updateImportSpecifier,
+
+    updateNullLiteral,
+
+    updateReturnStatement,
+
+    updateStringLiteral,
+
+    updateSuperExpression,
+
+    updateTSAsExpression,
+
+    updateTSClassImplements,
+
+    updateInterfaceBody : updateTSInterfaceBody,
+
+    updateTSNonNullExpression,
+
+    updateTSTypeParameterDeclaration,
+
+    updateTSTypeParameterInstantiation,
+
+    updateTemplateLiteral,
+
+    updateThisExpression,
+
+    updateUndefinedLiteral
 }

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