diff --git a/arkui-plugins/memo-plugins/signature-transformer.ts b/arkui-plugins/memo-plugins/signature-transformer.ts index b7fa8a62d37b9500e7e334a9cf66ee816279e993..6c15cce2ddbb03b30833c632b4b4edeaa8229772 100644 --- a/arkui-plugins/memo-plugins/signature-transformer.ts +++ b/arkui-plugins/memo-plugins/signature-transformer.ts @@ -129,8 +129,7 @@ export class SignatureTransformer extends AbstractVisitor { const expr = node.part.name; const decl = arkts.getDecl(expr); if (!decl || !arkts.isTSTypeAliasDeclaration(decl)) { - console.error(`@memo parameter's type has not been declared`); - throw 'Invalid @memo usage'; + return node as any as T; } const memoDecl = isMemoTSTypeAliasDeclaration(decl); if (memoDecl) { diff --git a/koala-wrapper/src/arkts-api/factory/nodeFactory.ts b/koala-wrapper/src/arkts-api/factory/nodeFactory.ts index 73fade7ba7196cfb52d622a18d440eb4af8f5e85..6b0de31f4db00f66fd268224495c590fedabb2e9 100644 --- a/koala-wrapper/src/arkts-api/factory/nodeFactory.ts +++ b/koala-wrapper/src/arkts-api/factory/nodeFactory.ts @@ -81,6 +81,7 @@ import { ForOfStatement, SwitchStatement, SwitchCaseStatement, + SpreadElement, } from '../../generated'; import { updateIdentifier } from '../node-utilities/Identifier'; import { updateCallExpression } from '../node-utilities/CallExpression'; @@ -142,6 +143,7 @@ import { updateForInStatement } from '../node-utilities/ForInStatement'; import { updateForOfStatement } from '../node-utilities/ForOfStatement'; import { updateSwitchStatement } from '../node-utilities/SwitchStatement'; import { updateSwitchCaseStatement } from '../node-utilities/SwitchCaseStatement'; +import { updateSpreadElement } from '../node-utilities/SpreadElement'; export const factory = { get createIdentifier(): (...args: Parameters) => Identifier { @@ -617,6 +619,12 @@ export const factory = { get updateSwitchCaseStatement(): (...args: Parameters) => SwitchCaseStatement { return updateSwitchCaseStatement; }, + get createSpreadElement(): (...args: Parameters) => SpreadElement { + return SpreadElement.createSpreadElement; + }, + get updateSpreadElement(): (...args: Parameters) => SpreadElement { + return updateSpreadElement; + }, /** @deprecated */ createTypeParameter1_(name: Identifier, constraint?: TypeNode, defaultType?: TypeNode) { return TSTypeParameter.createTSTypeParameter(Identifier.create1Identifier(name.name), constraint, defaultType); diff --git a/koala-wrapper/src/arkts-api/node-utilities/SpreadElement.ts b/koala-wrapper/src/arkts-api/node-utilities/SpreadElement.ts new file mode 100644 index 0000000000000000000000000000000000000000..f8e24176deed5b2fda83d523f7a434a7bebe2b0d --- /dev/null +++ b/koala-wrapper/src/arkts-api/node-utilities/SpreadElement.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 { Expression, SpreadElement } from '../../generated'; +import { isSameNativeObject } from '../peers/ArktsObject'; +import { attachModifiers, updateThenAttach } from '../utilities/private'; +import { Es2pandaAstNodeType } from '../../Es2pandaEnums'; +import { global } from '../static/global'; + +export function updateSpreadElement( + original: SpreadElement, + nodeType: Es2pandaAstNodeType, + argument?: Expression +): SpreadElement { + const originalNodeType = global.generatedEs2panda._AstNodeTypeConst(global.context, original.peer); + if (isSameNativeObject(argument, original.argument) && isSameNativeObject(nodeType, originalNodeType)) { + return original; + } + + const update = updateThenAttach(SpreadElement.updateSpreadElement, attachModifiers); + return update(original, nodeType, argument); +} diff --git a/koala-wrapper/src/arkts-api/visitor.ts b/koala-wrapper/src/arkts-api/visitor.ts index a08392e69ede0c9a545e530a3ff83d7e5134050c..4c2b6e7e7357f83d1a5d3eb120bba7636f502513 100644 --- a/koala-wrapper/src/arkts-api/visitor.ts +++ b/koala-wrapper/src/arkts-api/visitor.ts @@ -56,6 +56,7 @@ import { isETSFunctionType, isSwitchStatement, isSwitchCaseStatement, + isSpreadElement, } from '../generated'; import { isEtsScript, @@ -224,6 +225,10 @@ function visitTrivialExpression(node: AstNode, visitor: Visitor): AstNode { node.operatorType ); } + if (isSpreadElement(node)) { + const nodeType = global.generatedEs2panda._AstNodeTypeConst(global.context, node.peer); + return factory.updateSpreadElement(node, nodeType, nodeVisitor(node.argument, visitor)); + } // TODO return node; } diff --git a/koala-wrapper/src/generated/peers/SpreadElement.ts b/koala-wrapper/src/generated/peers/SpreadElement.ts index 4b721b9937fa524b766c9f1fee3ed6967cfde0f8..99aa74efe9913a92585551165d6fafd603fd6265 100644 --- a/koala-wrapper/src/generated/peers/SpreadElement.ts +++ b/koala-wrapper/src/generated/peers/SpreadElement.ts @@ -22,46 +22,77 @@ import { unpackNodeArray, assertValidPeer, AstNode, - Es2pandaAstNodeType, KNativePointer, nodeByType, ArktsObject, - unpackString -} from "../../reexport-for-generated" + unpackString, + Es2pandaAstNodeType, +} from '../../reexport-for-generated'; + +import { AnnotatedExpression } from './AnnotatedExpression'; +import { Decorator } from './Decorator'; +import { Expression } from './Expression'; +import { TypeNode } from './TypeNode'; +import { ValidationInfo } from './ValidationInfo'; -import { AnnotatedExpression } from "./AnnotatedExpression" -import { Expression } from "./Expression" -import { Decorator } from "./Decorator" -import { ValidationInfo } from "./ValidationInfo" -import { TypeNode } from "./TypeNode" export class SpreadElement extends AnnotatedExpression { - constructor(pointer: KNativePointer) { - super(pointer) - + constructor(pointer: KNativePointer) { + assertValidPeer(pointer, Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT); + super(pointer); + } + static createSpreadElement(nodeType: Es2pandaAstNodeType, argument?: Expression): SpreadElement { + const result: SpreadElement = new SpreadElement( + global.generatedEs2panda._CreateSpreadElement(global.context, nodeType, passNode(argument)) + ); + result.updateChildren(); + return result; + } + static updateSpreadElement( + original: SpreadElement | undefined, + nodeType: Es2pandaAstNodeType, + argument?: Expression + ): SpreadElement { + const result: SpreadElement = new SpreadElement( + global.generatedEs2panda._UpdateSpreadElement( + global.context, + passNode(original), + nodeType, + passNode(argument) + ) + ); + result.updateChildren(); + return result; } get argument(): Expression | undefined { - return unpackNode(global.generatedEs2panda._SpreadElementArgumentConst(global.context, this.peer)) + return unpackNode(global.generatedEs2panda._SpreadElementArgument(global.context, this.peer)); } get isOptional(): boolean { - return global.generatedEs2panda._SpreadElementIsOptionalConst(global.context, this.peer) + return global.generatedEs2panda._SpreadElementIsOptionalConst(global.context, this.peer); } get decorators(): readonly Decorator[] { - return unpackNodeArray(global.generatedEs2panda._SpreadElementDecoratorsConst(global.context, this.peer)) + return unpackNodeArray(global.generatedEs2panda._SpreadElementDecoratorsConst(global.context, this.peer)); } /** @deprecated */ setOptional(optional_arg: boolean): this { - global.generatedEs2panda._SpreadElementSetOptional(global.context, this.peer, optional_arg) - return this + global.generatedEs2panda._SpreadElementSetOptional(global.context, this.peer, optional_arg); + return this; + } + get validateExpression(): ValidationInfo | undefined { + return new ValidationInfo(global.generatedEs2panda._SpreadElementValidateExpression(global.context, this.peer)); } get typeAnnotation(): TypeNode | undefined { - return unpackNode(global.generatedEs2panda._SpreadElementTypeAnnotationConst(global.context, this.peer)) + return unpackNode(global.generatedEs2panda._SpreadElementTypeAnnotationConst(global.context, this.peer)); } /** @deprecated */ - setTsTypeAnnotation(typeAnnotation: TypeNode): this { - global.generatedEs2panda._SpreadElementSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation)) - return this + setTsTypeAnnotation(typeAnnotation?: TypeNode): this { + global.generatedEs2panda._SpreadElementSetTsTypeAnnotation(global.context, this.peer, passNode(typeAnnotation)); + return this; } + protected readonly brandSpreadElement: undefined; +} +export function isSpreadElement(node: object | undefined): node is SpreadElement { + return node instanceof SpreadElement; +} +if (!nodeByType.has(Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT)) { + nodeByType.set(Es2pandaAstNodeType.AST_NODE_TYPE_SPREAD_ELEMENT, SpreadElement); } -export function isSpreadElement(node: AstNode): node is SpreadElement { - return node instanceof SpreadElement -} \ No newline at end of file