From 545d5e1f8d26c6e58b42e08eaa1ea6b8a79ef972 Mon Sep 17 00:00:00 2001 From: w30045791 Date: Tue, 8 Jul 2025 19:43:43 +0800 Subject: [PATCH 1/2] wrapper and node_util Signed-off-by: w30045791 --- .../src/api_check_wrapper.ts | 165 ++ .../utils/ts_wrapper_node_util.ts | 1760 +++++++++++++++++ 2 files changed, 1925 insertions(+) diff --git a/build-tools/compiler-plugins/api-check-plugin-static/api-check-wrapper/src/api_check_wrapper.ts b/build-tools/compiler-plugins/api-check-plugin-static/api-check-wrapper/src/api_check_wrapper.ts index e69de29bb2..fc6a1ff0bf 100644 --- a/build-tools/compiler-plugins/api-check-plugin-static/api-check-wrapper/src/api_check_wrapper.ts +++ b/build-tools/compiler-plugins/api-check-plugin-static/api-check-wrapper/src/api_check_wrapper.ts @@ -0,0 +1,165 @@ +/* + * Copyright (c) 2022-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 * as arkts from '@koalaui/libarkts'; +import { traverseProgram, getJSDocInformation } from '../utils/ts_wrapper_node_util' +import { ApiCheckWrapperServiceHost, JsDocNodeCheckConfig, FileCheckModuleInfo, JSDoc, JSDocTag, JsDocNodeCheckConfigItem, CurrentAddress } from '../utils/api_check_wrapper_typedef' +import { SINCE_TAG_NAME } from "../../utils/api_check_plugin_define"; +import { parseCommand2JSDoc } from '../utils/api_check_wrapper_utils'; +export let curApiCheckWrapper: ApiCheckWrapper; +export let curFileCheckModuleInfo: FileCheckModuleInfo; + +/** + * 导出arkts命名空间 + */ +export const WrapeprApi = { + ...arkts +} +/** + * 遍历节点树 + * @param sourcefile + */ +export class ApiCheckWrapper { + constructor(apiCheckHost: ApiCheckWrapperServiceHost) { + this.apiCheckHost = apiCheckHost; + } + setFileName(fileName: string) { + this.fileName = fileName; + } + + fileName: string; // ets源文件位置 + + sourcefile: string; // 声明节点位置 + + apiCheckHost: ApiCheckWrapperServiceHost; +} +export function checkApiExpression(apiCheckHost: ApiCheckWrapperServiceHost, peer: number | undefined) { + curApiCheckWrapper = new ApiCheckWrapper(apiCheckHost) + curApiCheckWrapper.fileName = arkts.arktsGlobal.filePath + curFileCheckModuleInfo = {} as FileCheckModuleInfo + curFileCheckModuleInfo.currentFileName = arkts.arktsGlobal.filePath + const contextPtr = arkts.arktsGlobal.compilerContext?.peer ?? peer + // 获取当前ets文件路径，设置参数 + if (!!contextPtr) { + let program = arkts.getOrUpdateGlobalContext(contextPtr).program + let script = program.astNode; + // 获取根节点，开始遍历 + traverseProgram(script) + } + +} + +/** + * 处理identifier + * @param node + */ +export function checkIdntifier(node: arkts.AstNode) { + // 获取声明节点 + const decl = arkts.getDecl(node) + + if (decl === undefined || decl === null) { + console.log("debug decl error" + node.dumpJson()) + return + } + let sysPath = getSysPath(decl) + curApiCheckWrapper.sourcefile = sysPath; + + if (sysPath === undefined || sysPath === null) { + console.log("debug sysPath error :" + node.dumpJson()) + return + } + let checkPram: JsDocNodeCheckConfig = curApiCheckWrapper.apiCheckHost.getJsDocNodeCheckedConfig(curFileCheckModuleInfo.currentFileName, sysPath) + if (!checkPram.nodeNeedCheck) { + return + } + // 如果是系统接口， 进入检查jsdoc流程 + expressionCheckByJsDoc(decl, node, curApiCheckWrapper.fileName, checkPram.checkConfig) +} + +function getSysPath(decl: arkts.AstNode): string { + // 获取节点的声明节点， + let program = arkts.getProgramFromAstNode(decl) + + return program.sourceFilePath +} + +export function getPeerJsDocs(decl: arkts.AstNde): string { + return getJSDocInformation(decl) +} + + +function expressionCheckByJsDoc(declaration: arkts.AstNode, identifier: arkts.AstNode, sourceFile: string, checkConfig: JsDocNodeCheckConfigItem[]): void { + const jsDocsString = getPeerJsDocs(declaration) + const jsDocs: JSDoc[] = parseCommand2JSDoc(jsDocsString) + const jsDocTags = getCurrentJSDoc(jsDocs) + const address = getCurrentAddressByNode(identifier); + for (let i = 0; i < checkConfig.length; i++) { + const config = checkConfig[i] + let tagNameExisted = false + jsDocTags.forEach((item) => { + if (config.tagName.includes(item.tag)) { + if (config.checkValidCallback) { + tagNameExisted = config.checkValidCallback(jsDocs, config) + } else { + tagNameExisted = true + } + } + if (tagNameExisted && !config.tagNameShouldExisted) { + curApiCheckWrapper.apiCheckHost.pushLogInfo(identifier.name, curApiCheckWrapper.fileName, address, config.type, config.message) + } + }); + if (config.tagNameShouldExisted && !tagNameExisted) { + curApiCheckWrapper.apiCheckHost.pushLogInfo(identifier.name, curApiCheckWrapper.fileName, address, config.type, config.message) + } + } +} + +/** + * 获取节点行列信息 + * @param node 需要获取行列信息的节点 + * @returns 节点行列信息 + */ +function getCurrentAddressByNode(node: arkts.AstNode): CurrentAddress { + let address = {} as CurrentAddress; + let startPostion = node.startPostion; + address.column = startPostion.index; + address.line = startPostion.line; + return address; +} + +/** Get Current JSDoc. */ +function getCurrentJSDoc(jsDocs: JSDoc[]): JSDocTag[] { + let jsDocTags: JSDocTag[] = []; + let maxVersion: number = 0; + if (jsDocs && jsDocs.length > 0) { + for (let i = 0; i < jsDocs.length; i++) { + const jsdoc: JSDoc = jsDocs[i]; + if (jsdoc.tags && jsdoc.tags.length > 0) { + for (let j = 0; j < jsdoc.tags.length; j++) { + const tag: JSDocTag = jsdoc.tags[j]; + if (tag.tag === SINCE_TAG_NAME) { + const currentVersion: number = Number.parseInt(tag.name); + if (!Number.isNaN(currentVersion) && currentVersion > maxVersion) { + maxVersion = currentVersion; + jsDocTags = jsdoc.tags; + } + break; + } + } + } + } + } + return jsDocTags; +} diff --git a/build-tools/compiler-plugins/api-check-plugin-static/api-check-wrapper/utils/ts_wrapper_node_util.ts b/build-tools/compiler-plugins/api-check-plugin-static/api-check-wrapper/utils/ts_wrapper_node_util.ts index e69de29bb2..87dfe346b0 100644 --- a/build-tools/compiler-plugins/api-check-plugin-static/api-check-wrapper/utils/ts_wrapper_node_util.ts +++ b/build-tools/compiler-plugins/api-check-plugin-static/api-check-wrapper/utils/ts_wrapper_node_util.ts @@ -0,0 +1,1760 @@ +import * as arkts from '@koalaui/libarkts'; +import { checkIdntifier } from "../src/api_check_wrapper" +export function traverseProgram(node: arkts.AstNode) { + // 处理Identifier + if (!!node.statements) { + node.statements.forEach((item: arkts.AstNode) => handleAstNode(item)) + } +} + +type NodeTuple = [string, number]; +const items: NodeTuple[] = []; +const isDebug = false; +const nodeMap = new Map(); + +export function getJSDocInformation(node: arkts.AstNode): string { + return arkts.classDefinitionJSDocInformation(node); +} + +export const nodeHandleFunctionMap = new Map void>([ + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION, handleAssignmentExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE, handleAnnotatedAstNode], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_LABELLED_STATEMENT, handleLabelledStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_THROW_STATEMENT, handleThrowStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY, handleClassProperty], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_VOID_KEYWORD, handleTSVoidKeyword], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_FUNCTION_TYPE, handleETSFunctionType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_OPERATOR, handleTSTypeOperator], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_IF_STATEMENT, handleIfStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONSTRUCTOR_TYPE, handleTSConstructorType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_DECORATOR, handleDecorator], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_DECLARATION, handleTSEnumDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_NEVER_KEYWORD, handleTSNeverKeyword], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DEFAULT_SPECIFIER, handleImportDefaultSpecifier], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_SPECIFIER, handleImportSpecifier], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_CONDITIONAL_EXPRESSION, handleConditionalExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_CALL_EXPRESSION, handleCallExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_BIGINT_LITERAL, handleBigIntLiteral], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_TYPE, handleTSImportType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TAGGED_TEMPLATE_EXPRESSION, handleTaggedTemplateExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION, handleFunctionDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE, handleETSTypeReference], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_REFERENCE, handleTSTypeReference], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_NAMED_TYPE, handleNamedType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_NUMBER_LITERAL, handleNumberLiteral], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_FUNCTION_TYPE, handleTSFunctionType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_ELEMENT, handleTemplateElement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION, handleTSInterfaceDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION, handleVariableDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_UNDEFINED_LITERAL, handleUndefinedLiteral], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_MEMBER_EXPRESSION, handleMemberExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_CLASS_IMPLEMENTS, handleTSClassImplements], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_OBJECT_KEYWORD, handleTSObjectKeyword], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNION_TYPE, handleETSUnionType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_PROPERTY_SIGNATURE, handleTSPropertySignature], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_CONDITIONAL_TYPE, handleTSConditionalType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_LITERAL_TYPE, handleTSLiteralType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION, handleTSTypeAliasDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_DEBUGGER_STATEMENT, handleDebuggerStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_RETURN_STATEMENT, handleReturnStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_DEFAULT_DECLARATION, handleExportDefaultDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION, handleScriptFunction], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION, handleClassDefinition], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_BODY, handleTSInterfaceBody], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_QUERY, handleTSTypeQuery], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_BIGINT_KEYWORD, handleTSBigintKeyword], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_PROPERTY, handleProperty], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATOR, handleVariableDeclarator], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_STRING_LITERAL, handleStringLiteral], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ASSERTION, handleTSTypeAssertion], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_EXTERNAL_MODULE_REFERENCE, handleTSExternalModuleReference], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNDEFINED_KEYWORD, handleTSUndefinedKeyword], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TUPLE, handleETSTuple], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TRY_STATEMENT, handleTryStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_UNARY_EXPRESSION, handleUnaryExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_FOR_IN_STATEMENT, handleForInStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_THIS_EXPRESSION, handleThisExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_METHOD_SIGNATURE, handleTSMethodSignature], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_BINARY_EXPRESSION, handleBinaryExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_SUPER_EXPRESSION, handleSuperExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ASSERT_STATEMENT, handleAssertStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_STRING_KEYWORD, handleTSStringKeyword], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_EXPRESSION_STATEMENT, handleExpressionStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, handleETSModule], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_META_PROPERTY_EXPRESSION, handleMetaProperty], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_ARRAY_TYPE, handleTSArrayType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_SIGNATURE_DECLARATION, handleTSSignatureDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_ALL_DECLARATION, handleExportAllDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_SPECIFIER, handleExportSpecifier], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_TUPLE_TYPE, handleTSTupleType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_EXPRESSION, handleFunctionExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEX_SIGNATURE, handleTSIndexSignature], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_DECLARATION, handleTSModuleDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_DECLARATION, handleImportDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARENT_TYPE, handleTSParenthesizedType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_CHAR_LITERAL, handleCharLiteral], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PACKAGE_DECLARATION, handleETSPackageDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_IMPORT_DECLARATION, handleETSImportDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_STRUCT_DECLARATION, handleETSStructDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_MODULE_BLOCK, handleTSModuleBlock], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_ARRAY_INSTANCE_EXPRESSION, handleETSNewArrayInstanceExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_DECLARATION, handleAnnotationDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ANNOTATION_USAGE, handleAnnotationUsage], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_EMPTY_STATEMENT, handleEmptyStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_WHILE_STATEMENT, handleWhileStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_CHAIN_EXPRESSION, handleChainExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERSECTION_TYPE, handleTSIntersectionType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_UPDATE_EXPRESSION, handleUpdateExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_EXPRESSION, handleBlockExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_LITERAL, handleTSTypeLiteral], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER, handleTSTypeParameter], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL, handleTSBooleanKeyword], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PREDICATE, handleTSTypePredicate], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_NAMESPACE_SPECIFIER, handleImportNamespaceSpecifier], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_EXPORT_NAMED_DECLARATION, handleExportNamedDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PARAMETER_EXPRESSION, handleETSParameterExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_INSTANTIATION, handleTSTypeParameterInstantiation], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_NULL_LITERAL, handleNullLiteral], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_INFER_TYPE, handleTSInferType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_CASE_STATEMENT, handleSwitchCaseStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_YIELD_EXPRESSION, handleYieldExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_IMPORT_EQUALS_DECLARATION, handleTSImportEqualsDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_BOOLEAN_LITERAL, handleBooleanLiteral], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_NUMBER_KEYWORD, handleTSNumberKeyword], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_STATIC_BLOCK, handleClassStaticBlock], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_NON_NULL_EXPRESSION, handleTSNonNullExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_PREFIX_ASSERTION_EXPRESSION, handlePrefixAssertionExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_EXPRESSION, handleClassExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_FOR_OF_STATEMENT, handleForOfStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TEMPLATE_LITERAL, handleTemplateLiteral], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNION_TYPE, handleTSUnionType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_UNKNOWN_KEYWORD, handleTSUnknownKeyword], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_IDENTIFIER, handleIdentifier], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_OPAQUE_TYPE_NODE, handleOpaqueTypeNode], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_BLOCK_STATEMENT, handleBlockStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_DIRECT_EVAL, handleDirectEvalExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_PARAMETER_DECLARATION, handleTSTypeParameterDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_METHOD_DEFINITION, handleMethodDefinition], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_NULL_KEYWORD, handleTSNullKeyword], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_HERITAGE, handleTSInterfaceHeritage], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_CLASS_LITERAL, handleETSClassLiteral], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_BREAK_STATEMENT, handleBreakStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_REGEXP_LITERAL, handleRegExpLiteral], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_MAPPED_TYPE, handleTSMappedType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_ANY_KEYWORD, handleTSAnyKeyword], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DECLARATION, handleClassDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_INDEXED_ACCESS_TYPE, handleTSIndexedAccessType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_QUALIFIED_NAME, handleTSQualifiedName], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_AWAIT_EXPRESSION, handleAwaitExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_CONTINUE_STATEMENT, handleContinueStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_MULTI_DIM_ARRAY_INSTANCE_EXPRESSION, handleETSNewMultiDimArrayInstanceExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_NAMED_TUPLE_MEMBER, handleTSNamedTupleMember], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_IMPORT_EXPRESSION, handleImportExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NULL_TYPE, handleETSNullType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_UNDEFINED_TYPE, handleETSUndefinedType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TYPEOF_EXPRESSION, handleTypeofExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_ENUM_MEMBER, handleTSEnumMember], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_SWITCH_STATEMENT, handleSwitchStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_DO_WHILE_STATEMENT, handleDoWhileStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_CATCH_CLAUSE, handleCatchClause], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_SEQUENCE_EXPRESSION, handleSequenceExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, handleArrowFunctionExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_OMITTED_EXPRESSION, handleOmittedExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_NEW_CLASS_INSTANCE_EXPRESSION, handleETSNewClassInstanceExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_AS_EXPRESSION, handleTSAsExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_FOR_UPDATE_STATEMENT, handleForUpdateStatement], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_TYPE_REFERENCE_PART, handleETSTypeReferencePart], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_REEXPORT_STATEMENT, handleETSReExportDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_PRIMITIVE_TYPE, handleETSPrimitiveType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_NEW_EXPRESSION, handleNewExpression], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_PARAMETER_PROPERTY, handleTSParameterProperty], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_WILDCARD_TYPE, handleETSWildcardType], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_THIS_TYPE, handleTSThisType], +]) + +/** + * 通用日志处理 + * @param node + * @param fuc + */ +function handleFunction(node: arkts.AstNode, func: (node: any, ...args: any[]) => void, isNeedAddPath?: boolean) { + if (isDebug) { + console.log('[JSDOC_CHECK PLUGIN] ' + func.name); + if (isNeedAddPath) { + items.push([func.name, node.peer.toString()]); + } + console.log("path: " + console.log(JSON.stringify(items))); + } + + func(node); + + if (isDebug && isNeedAddPath) { + if (nodeMap.has(node.peer.toString())) { + if (nodeMap.get(node.peer.toString()) > 2) { + console.error("[JSDOC_CHECK PLUGIN] repeat traverse") + } + nodeMap.set(node.peer.toString(), nodeMap.get(node.peer.toString()) + 1) + } else { + nodeMap.set(node.peer.toString(), 1) + } + items.pop(); + } +} + +export function handleAstNode(node: arkts.AstNode) { + if (isDebug) { + console.log('[JSDOC_CHECK PLUGIN] handleAstNode'); + } + let kind: number = arkts.arktsGlobal.generatedEs2panda._AstNodeTypeConst(arkts.arktsGlobal.context, node.peer) + if (nodeHandleFunctionMap.has(kind) && nodeHandleFunctionMap.get(kind) !== undefined) { + handleFunction(node, nodeHandleFunctionMap.get(kind)!, true) + } else { + console.log("[JSDOC_CHECK PLUGIN] debug handleAstNode " + node.constructor.name + " error!") + } +} + +export function handleAnnotatedAstNode(node: arkts.AstNode) { +} +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleAnnotatedExpression(node: arkts.AstNode) { + if (!!node.typeAnnotation) { + handleAstNode(node.typeAnnotation) + } + handleExpression(node) +} + +export function handleAnnotatedStatement(node: arkts.AstNode) { + handleStatement(node) +} + +export function handleAnnotationDeclaration(node: arkts.AstNode) { + if (!!node.expr) { + handleAstNode(node.expr) + } + if (!!node.properties) { + node.properties.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } + handleStatement(node) +} + +export function handleAnnotationUsage(node: arkts.AstNode) { + if (!!node.expr) { + handleAstNode(node.expr) + } + if (!!node.properties) { + node.properties.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + handleStatement(node) +} + +export function handleArrayExpression(node: arkts.AstNode) { + if (!!node.elements) { + node.elements.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + if (!!node.declarators) { + node.declarators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) + } + if (!!node.typeAnnotation) { + handleAstNode(node.typeAnnotation) + } + handleAnnotatedExpression(node) +} + +export function handleArrowFunctionExpression(node: arkts.AstNode) { + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } + if (!!node.scriptFunction) { + handleAstNode(node.scriptFunction) + } + handleExpression(node) +} + +export function handleAssertStatement(node: arkts.AstNode) { + if (!!node.test) { + handleAstNode(node.test) + } + if (!!node.second) { + handleAstNode(node.second) + } + handleStatement(node) +} + +export function handleAssignmentExpression(node: arkts.AstNode) { + if (!!node.left) { + handleAstNode(node.left) + } + if (!!node.right) { + handleAstNode(node.right) + } + handleExpression(node) +} + +export function handleAstDumper(node: arkts.AstNode) { + return +} + +export function handleAwaitExpression(node: arkts.AstNode) { + if (!!node.argument) { + handleAstNode(node.argument) + } + handleExpression(node) +} + +export function handleBigIntLiteral(node: arkts.AstNode) { + handleLiteral(node) +} + +export function handleBinaryExpression(node: arkts.AstNode) { + if (!!node.left) { + handleAstNode(node.left) + } + if (!!node.right) { + handleAstNode(node.right) + } + if (!!node.result) { + handleAstNode(node.result) + } + handleExpression(node) +} + +export function handleBlockExpression(node: arkts.AstNode) { + if (!!node.statements) { + node.statements.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + handleExpression(node) +} + +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleBlockStatement(node: arkts.AstNode) { + if (!!node.statements) { + node.statements.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + handleStatement(node) +} + +export function handleBooleanLiteral(node: arkts.AstNode) { + handleLiteral(node) +} + +export function handleBreakStatement(node: arkts.AstNode) { + if (!!node.ident) { + handleFunction(node.ident, handleIdentifier) + } + if (!!node.target) { + handleAstNode(node.target) + } + handleStatement(node) +} + +export function handleCallExpression(node: arkts.AstNode) { + if (!!node.trailingBlock) { + handleAstNode(node.trailingBlock) + } + if (!!node.expression) { + handleAstNode(node.expression) + } + if (!!node.typeArguments) { + node.typeArguments.forEach((item: arkts.TypeNode) => handleAstNode(item)) + } + if (!!node.arguments) { + node.arguments.forEach((item: arkts.Expression) => handleAstNode(item)) + } + if (!!node.params) { + node.params.forEach((item: arkts.TypeNode) => handleAstNode(item)) + } + handleExpression(node) +} + +export function handleCatchClause(node: arkts.AstNode) { + if (!!node.param) { + handleAstNode(node.param) + } + if (!!node.body) { + handleAstNode(node.body) + } + handleTypedStatement(node) +} + +export function handleChainExpression(node: arkts.AstNode) { + if (!!node.getExpression) { + handleAstNode(node.getExpression) + } + handleExpression(node) +} + +export function handleCharLiteral(node: arkts.AstNode) { + handleLiteral(node) +} + +export function handleClassDeclaration(node: arkts.AstNode) { + if (!!node.definition) { + handleFunction(node.definition, handleClassDefinition) + } + if (!!node.decorators) { + node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) + } + handleStatement(node) +} + +export function handleClassDefinition(node: arkts.AstNode) { + if (!!node.ident) { + handleFunction(node.ident, handleIdentifier) + } + if (!!node.super) { + handleAstNode(node.super); + } + if (!!node.body) { + node.body.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + if (!!node.implments) { + node.implments.forEach((item: arkts.AstNode) => handleFunction(item, handleTSClassImplements)) + } + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterDeclaration) + } + if (!!node.superTypeParams) { + handleFunction(node.superTypeParams, handleTSTypeParameterInstantiation) + } + if (!!node.origEnumDecl) { + handleFunction(node.origEnumDecl, handleTSEnumDeclaration) + } + if (!!node.getAnonClass) { + handleAstNode(node.getAnonClass) + } + handleTypedAstNode(node) +} + +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleClassElement(node: arkts.AstNode) { + if (!!node.key) { + handleAstNode(node.key) + } + if (!!node.value) { + handleAstNode(node.value) + } + if (!!node.decorators) { + node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) + } + handleTypedStatement(node) +} + +export function handleClassExpression(node: arkts.AstNode) { + if (!!node.definition) { + handleFunction(node.definition, handleClassDefinition) + } + handleExpression(node) +} + +export function handleClassProperty(node: arkts.AstNode) { + if (!!node.typeAnnotation) { + handleAstNode(node.typeAnnotation) + } + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } + handleClassElement(node) +} + +export function handleClassStaticBlock(node: arkts.AstNode) { + handleClassElement(node) +} + +export function handleConditionalExpression(node: arkts.AstNode) { + if (!!node.test) { + handleAstNode(node.test) + } + if (!!node.consequent) { + handleAstNode(node.consequent) + } + if (!!node.alternate) { + handleAstNode(node.alternate) + } + handleExpression(node) +} + +export function handleContext(node: arkts.AstNode) { +} + +export function handleContinueStatement(node: arkts.AstNode) { + if (!!node.ident) { + handleFunction(node.ident, handleIdentifier) + } + if (!!node.target) { + handleAstNode(node.target) + } + handleStatement(node) +} + +export function handleDebuggerStatement(node: arkts.AstNode) { + handleStatement(node) +} + +export function handleDecorator(node: arkts.AstNode) { + if (!!node.expr) { + handleAstNode(node.expr) + } + handleStatement(node) +} + +export function handleDirectEvalExpression(node: arkts.AstNode) { + handleCallExpression(node) +} + +export function handleDoWhileStatement(node: arkts.AstNode) { + if (!!node.test) { + handleAstNode(node.test) + } + if (!!node.body) { + handleAstNode(node.body) + } + handleLoopStatement(node) +} + +export function handleETSClassLiteral(node: arkts.AstNode) { + if (!!node.expr) { + handleAstNode(node.expr) + } + handleExpression(node) +} + +export function handleETSDynamicFunctionType(node: arkts.AstNode) { + handleETSFunctionType(node) +} + +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleETSFunctionType(node: arkts.AstNode) { + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterDeclaration) + } + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + if (!!node.returnType) { + handleAstNode(node.returnType) + } + if (!!node.functionInterface) { + handleAstNode(node.functionInterface) + } + handleTypeNode(node) +} + +export function handleETSImportDeclaration(node: arkts.AstNode) { + handleImportDeclaration(node) +} + +export function handleETSModule(node: arkts.AstNode) { + if (!!node.ident) { + handleFunction(node.ident, handleIdentifier) + } + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } + handleBlockStatement(node) +} + +export function handleETSNewArrayInstanceExpression(node: arkts.AstNode) { + if (!!node.typeReference) { + handleAstNode(node.typeReference) + } + if (!!node.dimension) { + handleAstNode(node.dimension) + } + handleExpression(node) +} + +export function handleETSNewClassInstanceExpression(node: arkts.AstNode) { + if (!!node.getTypeRef) { + handleAstNode(node.getTypeRef) + } + if (!!node.getArgments) { + node.getArgments.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + handleExpression(node) +} + +export function handleETSNewMultiDimArrayInstanceExpression(node: arkts.AstNode) { + if (!!node.dimensions) { + node.dimensions.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + if (!!node.typeReference) { + handleAstNode(node.typeReference) + } + handleExpression(node) +} + +export function handleETSNullType(node: arkts.AstNode) { + handleTypeNode(node) +} + +export function handleETSPackageDeclaration(node: arkts.AstNode) { + handleStatement(node) +} + +export function handleETSParameterExpression(node: arkts.AstNode) { + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } + if (!!node.type) { + handleAstNode(node.type) + } + if (!!node.initializer) { + handleAstNode(node.initializer) + } + if (!!node.identifier) { + handleFunction(node.identifier, handleIdentifier) + } + handleExpression(node) +} + +export function handleETSPrimitiveType(node: arkts.AstNode) { + handleTypeNode(node) +} + +export function handleETSReExportDeclaration(node: arkts.AstNode) { + if (!!node.getETSImportDeclarations) { + handleFunction(node.getETSImportDeclarations, handleETSImportDeclaration) + } + handleStatement(node) +} + +export function handleETSStructDeclaration(node: arkts.AstNode) { + handleClassDeclaration(node) +} + +export function handleETSTuple(node: arkts.AstNode) { + if (!!node.getTupleTypeAnnotationsList) { + node.getTupleTypeAnnotationsList.forEach((item: arkts.AstNde) => handleAstNode(item)) + } + handleTypeNode(node) +} + +export function handleETSTypeReference(node: arkts.AstNode) { + if (!!node.part) { + handleFunction(node.part, handleETSTypeReferencePart) + } + handleTypeNode(node) +} + +export function handleETSTypeReferencePart(node: arkts.AstNode) { + if (!!node.previous) { + handleFunction(node.previous, handleETSTypeReferencePart) + } + if (!!node.name) { + handleAstNode(node.name) + } + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterInstantiation) + } + handleTypeNode(node) +} + +export function handleETSUndefinedType(node: arkts.AstNode) { + handleTypeNode(node) +} + +export function handleETSUnionType(node: arkts.AstNode) { + if (!!node.types) { + node.types.forEach((item: arkts.AstNde) => handleAstNode(item)) + } + handleTypeNode(node) +} + +export function handleETSWildcardType(node: arkts.AstNode) { + if (!!node.typeReference) { + handleFunction(node.typeReference, handleETSTypeReference) + } + handleTypeNode(node) +} + +export function handleEmptyStatement(node: arkts.AstNode) { + handleStatement(node) +} + +export function handleExportAllDeclaration(node: arkts.AstNode) { + if (!!node.source) { + handleFunction(node.source, handleStringLiteral) + } + if (!!node.exported) { + handleFunction(node.exported, handleIdentifier) + } + handleStatement(node) +} + +export function handleExportDefaultDeclaration(node: arkts.AstNode) { + if (!!node.decl) { + handleAstNode(node.decl) + } + handleStatement(node) +} + +export function handleExportNamedDeclaration(node: arkts.AstNode) { + if (!!node.decl) { + handleAstNode(node.decl) + } + if (!!node.source) { + handleFunction(node.source, handleStringLiteral) + } + if (!!node.specifiers) { + node.specifiers.forEach((item: arkts.AstNode) => handleFunction(item, handleExportSpecifier)) + } + handleStatement(node) +} + +export function handleExportSpecifier(node: arkts.AstNode) { + if (!!node.local) { + handleFunction(node.local, handleIdentifier) + } + if (!!node.exported) { + handleFunction(node.exported, handleIdentifier) + } + handleStatement(node) +} + +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + */ +export function handleExpression(node: arkts.AstNode) { +} + +export function handleExpressionStatement(node: arkts.AstNode) { + if (!!node.expression) { + handleAstNode(node.expression) + } + handleStatement(node) +} + +export function handleForInStatement(node: arkts.AstNode) { + if (!!node.left) { + handleAstNode(node.left) + } + if (!!node.right) { + handleAstNode(node.right) + } + if (!!node.body) { + handleAstNode(node.body) + } + handleLoopStatement(node) +} + +export function handleForOfStatement(node: arkts.AstNode) { + if (!!node.left) { + handleAstNode(node.left) + } + if (!!node.right) { + handleAstNode(node.right) + } + if (!!node.body) { + handleAstNode(node.body) + } + handleLoopStatement(node) +} + +export function handleForUpdateStatement(node: arkts.AstNode) { + if (!!node.init) { + handleAstNode(node.init) + } + if (!!node.test) { + handleAstNode(node.test) + } + if (!!node.update) { + handleAstNode(node.update) + } + if (!!node.body) { + handleAstNode(node.body) + } + handleLoopStatement(node) +} + +export function handleFunctionDecl(node: arkts.AstNode) { + handleScriptFunction(node) +} + +export function handleFunctionDeclaration(node: arkts.AstNode) { + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } + if (!!node.scriptFunction) { + handleAstNode(node.scriptFunction) + } + if (!!node.parameters) { + node.parameters.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + if (!!node.name) { + handleFunction(node.name, handleIdentifier) + } + if (!!node.body) { + handleAstNode(node.body) + } + if (!!node.typeParamsDecl) { + handleFunction(node.typeParamsDecl, handleTSTypeParameterDeclaration) + } + if (!!node.returnType) { + handleAstNode(node.returnType) + } + handleStatement(node) +} + +export function handleFunctionExpression(node: arkts.AstNode) { + if (!!node.scriptFunction) { + handleAstNode(node.scriptFunction) + } + handleExpression(node) +} + +export function handleFunctionSignature(node: arkts.AstNode) { + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterDeclaration) + } + if (!!node.returnType) { + handleAstNode(node.returnType) + } +} + +export function handleIdentifier(node: arkts.AstNode) { + checkIdntifier(node); + + if (!!node.decorators) { + node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) + } + if (!!node.typeAnnotation) { + handleAstNode(node.typeAnnotation) + } + handleAnnotatedExpression(node) +} + +export function handleIfStatement(node: arkts.AstNode) { + if (!!node.test) { + handleAstNode(node.test) + } + if (!!node.consequent) { + handleAstNode(node.consequent) + } + if (!!node.alternate) { + handleAstNode(node.alternate) + } + handleStatement(node) +} +/** + * import节点 不处理Identifier + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleImportDeclaration(node: arkts.AstNode) { +} + +export function handleImportDefaultSpecifier(node: arkts.AstNode) { + if (!!node.local) { + handleFunction(node.local, handleIdentifier) + } + handleStatement(node) +} + +export function handleImportExpression(node: arkts.AstNode) { + if (!!node.source) { + handleFunction(node.source, handleStringLiteral) + } + handleExpression(node) +} + +export function handleImportNamespaceSpecifier(node: arkts.AstNode) { + if (!!node.local) { + handleFunction(node.local, handleIdentifier) + } + handleStatement(node) +} + +export function handleImportSource(node: arkts.AstNode) { + if (!!node.source) { + handleFunction(node.source, handleStringLiteral) + } + if (!!node.resolvedSource) { + handleFunction(node.resolvedSource, handleStringLiteral) + } +} + +export function handleImportSpecifier(node: arkts.AstNode) { + if (!!node.imported) { + handleFunction(node.imported, handleIdentifier) + } + if (!!node.local) { + handleFunction(node.local, handleIdentifier) + } + handleStatement(node) +} + +export function handleInterfaceDecl(node: arkts.AstNode) { + handleTSInterfaceDeclaration(node) +} + +export function handleLabelPair(node: arkts.AstNode) { + if (!!node.ident) { + handleFunction(node.ident, handleIdentifier) + } + if (!!node.body) { + handleAstNode(node.body) + } +} + +export function handleLabelledStatement(node: arkts.AstNode) { + handleStatement(node) +} +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleLiteral(node: arkts.AstNode) { + handleExpression(node) +} +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleLoopStatement(node: arkts.AstNode) { + handleStatement(node) +} + +export function handleMaybeOptionalExpression(node: arkts.AstNode) { + handleExpression(node) +} + +export function handleMemberExpression(node: arkts.AstNode) { + if (!!node.object) { + handleAstNode(node.object) + } + if (!!node.property) { + handleAstNode(node.property) + } + handleExpression(node) +} + +export function handleMetaProperty(node: arkts.AstNode) { + handleExpression(node) +} + +export function handleMethodDefinition(node: arkts.AstNode) { + if (!!node.overloads) { + node.overloads.forEach((item: arkts.AstNode) => handleFunction(item, handleMethodDefinition)) + } + if (!!node.scriptFunction) { + handleAstNode(node.scriptFunction) + } + if (!!node.name) { + handleFunction(node.name, handleIdentifier) + } + handleClassElement(node) +} + +export function handleNamedType(node: arkts.AstNode) { + if (!!node.name) { + handleFunction(node.name, handleIdentifier) + } + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterInstantiation) + } + handleTypeNode(node) +} + +export function handleNewExpression(node: arkts.AstNode) { + if (!!node.callee) { + handleAstNode(node.callee) + } + if (!!node.arguments) { + node.arguments.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + handleExpression(node) +} + +export function handleNullLiteral(node: arkts.AstNode) { + handleLiteral(node) +} + +export function handleNumberLiteral(node: arkts.AstNode) { + handleLiteral(node) +} + +export function handleObjectExpression(node: arkts.AstNode) { + if (!!node.properties) { + node.properties.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + if (!!node.decorators) { + node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) + } + if (!!node.typeAnnotation) { + handleAstNode(node.typeAnnotation) + } + handleAnnotatedExpression(node) +} + +export function handleOmittedExpression(node: arkts.AstNode) { + handleExpression(node) +} + +export function handleOpaqueTypeNode(node: arkts.AstNode) { + handleTypeNode(node) +} + +export function handlePrefixAssertionExpression(node: arkts.AstNode) { + if (!!node.expr) { + handleAstNode(node.expr) + } + if (!!node.type) { + handleAstNode(node.type) + } + handleExpression(node) +} + +export function handleProperty(node: arkts.AstNode) { + if (!!node.key) { + handleAstNode(node.key) + } + if (!!node.value) { + handleAstNode(node.value) + } + handleExpression(node) +} + +export function handleRegExpLiteral(node: arkts.AstNode) { + handleLiteral(node) +} + +export function handleReturnStatement(node: arkts.AstNode) { + if (!!node.argument) { + handleAstNode(node.argument) + } + handleStatement(node) +} + +export function handleScriptFunction(node: arkts.AstNode) { + if (!!node.id) { + handleFunction(node.id, handleIdentifier) + } + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + if (!!node.returnStatements) { + node.returnStatements.forEach((item: arkts.AstNode) => handleFunction(item, handleReturnStatement)) + } + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterDeclaration) + } + if (!!node.body) { + handleAstNode(node.body) + } + if (!!node.returnTypeAnnotation) { + handleAstNode(node.returnTypeAnnotation) + } + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNde) => handleFunction(item, handleAnnotationUsage)) + } +} + +export function handleSequenceExpression(node: arkts.AstNode) { + if (!!node.sequence) { + node.sequence.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + handleExpression(node) +} + +export function handleSpreadElement(node: arkts.AstNode) { + if (!!node.argument) { + handleAstNode(node.argument) + } + if (!!node.decorators) { + node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) + } + if (!!node.typeAnnotation) { + handleAstNode(node.typeAnnotation) + } + handleAnnotatedExpression(node) +} + +export function handleSrcDumper(node: arkts.AstNode) { + return +} +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + */ +export function handleStatement(node: arkts.AstNode) { +} + +export function handleStringLiteral(node: arkts.AstNode) { + handleLiteral(node) +} + +export function handleSuperExpression(node: arkts.AstNode) { + if (!!node.id) { + handleFunction(node.id, handleIdentifier) + } + handleExpression(node) +} + +export function handleSwitchCaseStatement(node: arkts.AstNode) { + if (!!node.test) { + handleAstNode(node.test) + } + if (!!node.consequent) { + node.consequent.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + handleStatement(node) +} + +export function handleSwitchStatement(node: arkts.AstNode) { + if (!!node.discriminant) { + handleAstNode(node.discriminant) + } + if (!!node.cases) { + node.cases.forEach((item: arkts.AstNode) => handleFunction(item, handleSwitchCaseStatement)) + } + handleStatement(node) +} + +export function handleTSAnyKeyword(node: arkts.AstNode) { + handleTypeNode(node) +} + +export function handleTSArrayType(node: arkts.AstNode) { + if (!!node.elementType) { + handleAstNode(node.elementType) + } +} + +export function handleTSAsExpression(node: arkts.AstNode) { + if (!!node.expr) { + handleAstNode(node.expr) + } + if (!!node.typeAnnotation) { + handleAstNode(node.typeAnnotation) + } + handleAnnotatedExpression(node) +} + +export function handleTSBigintKeyword(node: arkts.AstNode) { + handleTypeNode(node) +} + +export function handleTSBooleanKeyword(node: arkts.AstNode) { + handleTypeNode(node) +} + +export function handleTSClassImplements(node: arkts.AstNode) { + if (!!node.expr) { + handleAstNode(node.expr) + } + if (!!node.typeParameters) { + handleFunction(node.typeParameters, handleTSTypeParameterInstantiation) + } + handleExpression(node) +} + +export function handleTSConditionalType(node: arkts.AstNode) { + if (!!node.checkType) { + handleAstNode(node.checkType) + } + if (!!node.extendsType) { + handleAstNode(node.extendsType) + } + if (!!node.trueType) { + handleAstNode(node.trueType) + } + if (!!node.falseType) { + handleAstNode(node.falseType) + } + handleTypeNode(node) +} + +export function handleTSConstructorType(node: arkts.AstNode) { + if (!!node.typeParams) { + handleFunction(node.typeParameters, handleTSTypeParameterInstantiation) + } + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + if (!!node.returnType) { + handleAstNode(node.returnType) + } + handleTypeNode(node) +} + +export function handleTSEnumDeclaration(node: arkts.AstNode) { + if (!!node.key) { + handleFunction(node.key, handleIdentifier) + } + if (!!node.members) { + node.members.forEach((item: arkts.AstNde) => handleAstNode(item)) + } + if (!!node.boxedClass) { + handleFunction(node.boxedClass, handleClassDefinition) + } + if (!!node.decorators) { + node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) + } + handleTypedStatement(node) +} + +export function handleTSEnumMember(node: arkts.AstNode) { + if (!!node.key) { + handleAstNode(node.key) + } + if (!!node.init) { + handleAstNode(node.init) + } + handleStatement(node) +} + +export function handleTSExternalModuleReference(node: arkts.AstNode) { + if (!!node.expr) { + handleAstNode(node.expr) + } + handleExpression(node) +} + +export function handleTSFunctionType(node: arkts.AstNode) { + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterInstantiation) + } + if (!!node.params) { + node.params.forEach((item: arkts.TypeNode) => handleAstNode(item)) + } + if (!!node.returnType) { + handleAstNode(node.returnType) + } + handleTypeNode(node) +} + +export function handleTSImportEqualsDeclaration(node: arkts.AstNode) { + if (!!node.id) { + handleFunction(node.id, handleIdentifier) + } + if (!!node.moduleReference) { + handleAstNode(node.moduleReference) + } + handleStatement(node) +} + +export function handleTSImportType(node: arkts.AstNode) { + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterInstantiation) + } + if (!!node.params) { + handleAstNode(node.params) + } + if (!!node.qualifier) { + handleAstNode(node.qualifier) + } + handleTypeNode(node) +} + +export function handleTSIndexSignature(node: arkts.AstNode) { + if (!!node.objectType) { + handleAstNode(node.objectType) + } + if (!!node.indexType) { + handleAstNode(node.indexType) + } + handleTypeNode(node) +} + +export function handleTSIndexedAccessType(node: arkts.AstNode) { + if (!!node.param) { + handleAstNode(node.param) + } + if (!!node.typeAnnotation) { + handleAstNode(node.typeAnnotation) + } + handleTypedAstNode(node) +} + +export function handleTSInferType(node: arkts.AstNode) { + if (!!node.typeParam) { + handleFunction(node.typeParam, handleTSTypeParameter) + } + handleTypeNode(node) +} + +export function handleTSInterfaceBody(node: arkts.AstNode) { + if (!!node.body) { + node.body.forEach((item: arkts.TypeNode) => handleAstNode(item)) + } + handleExpression(node) +} + +export function handleTSInterfaceDeclaration(node: arkts.AstNode) { + if (!!node.id) { + handleFunction(node.id, handleIdentifier) + } + if (!!node.body) { + handleFunction(node.body, handleTSInterfaceBody) + } + if (!!node.typeParams) { + handleFunction(node.typeParam, handleTSTypeParameterDeclaration) + } + if (!!node.extends) { + node.extends.forEach((item: arkts.TypeNode) => handleFunction(item, handleTSInterfaceHeritage)) + } + if (!!node.decorators) { + node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) + } + if (!!node.getAnonClass) { + handleAstNode(node.getAnonClass) + } + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } + handleTypedStatement(node) +} + +export function handleTSInterfaceHeritage(node: arkts.AstNode) { + if (!!node.expr) { + handleAstNode(node.expr) + } + handleExpression(node) +} + +export function handleTSIntersectionType(node: arkts.AstNode) { + if (!!node.types) { + node.types.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + handleTypeNode(node) +} + +export function handleTSLiteralType(node: arkts.AstNode) { + if (!!node.literal) { + handleAstNode(node.literal) + } + handleTypeNode(node) +} + +export function handleTSMappedType(node: arkts.AstNode) { + if (!!node.typeParameter) { + handleFunction(node.typeParameter, handleTSTypeParameter) + } + if (!!node.typeAnnotation) { + handleAstNode(node.typeAnnotation) + } + handleTypeNode(node) +} + +export function handleTSMethodSignature(node: arkts.AstNode) { + if (!!node.key) { + handleAstNode(node.key) + } + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterDeclaration) + } + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + if (!!node.returnTypeAnnotation) { + handleAstNode(node.returnTypeAnnotation) + } +} + +export function handleTSModuleBlock(node: arkts.AstNode) { + if (!!node.statements) { + node.statements.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + handleStatement(node) +} + +export function handleTSModuleDeclaration(node: arkts.AstNode) { + if (!!node.name) { + handleAstNode(node.name) + } + if (!!node.body) { + handleAstNode(node.body) + } + handleStatement(node) +} + +export function handleTSNamedTupleMember(node: arkts.AstNode) { + if (!!node.label) { + handleAstNode(node.label) + } + if (!!node.elementType) { + handleAstNode(node.elementType) + } + handleTypeNode(node) +} + +export function handleTSNeverKeyword(node: arkts.AstNode) { + handleTypeNode(node) +} + +export function handleTSNonNullExpression(node: arkts.AstNode) { + if (!!node.expr) { + handleAstNode(node.expr) + } + handleExpression(node) +} + +export function handleTSNullKeyword(node: arkts.AstNode) { + handleTypeNode(node) +} + +export function handleTSNumberKeyword(node: arkts.AstNode) { + handleTypeNode(node) +} + +export function handleTSObjectKeyword(node: arkts.AstNode) { + handleTypeNode(node) +} + +export function handleTSParameterProperty(node: arkts.AstNode) { + if (!!node.parameter) { + handleAstNode(node.parameter) + } + handleExpression(node) +} + +export function handleTSParenthesizedType(node: arkts.AstNode) { + if (!!node.type) { + handleAstNode(node.type) + } + handleTypeNode(node) +} + +export function handleTSPropertySignature(node: arkts.AstNode) { + if (!!node.key) { + handleAstNode(node.key) + } + if (!!node.typeAnnotation) { + handleAstNode(node.typeAnnotation) + } + handleAnnotatedAstNode(node) +} + +export function handleTSQualifiedName(node: arkts.AstNode) { + if (!!node.left) { + handleAstNode(node.left) + } + if (!!node.right) { + handleFunction(node.right, handleIdentifier) + } + handleExpression(node) +} + +export function handleTSSignatureDeclaration(node: arkts.AstNode) { + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterDeclaration) + } + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + if (!!node.returnTypeAnnotation) { + handleAstNode(node.returnTypeAnnotation) + } + handleTypedAstNode(node) +} + +export function handleTSStringKeyword(node: arkts.AstNode) { + handleTypeNode(node) +} + +export function handleTSThisType(node: arkts.AstNode) { + handleTypeNode(node) +} + +export function handleTSTupleType(node: arkts.AstNode) { + if (!!node.elementType) { + node.elementType.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + handleTypeNode(node) +} + +export function handleTSTypeAliasDeclaration(node: arkts.AstNode) { + if (!!node.id) { + handleFunction(node.id, handleIdentifier) + } + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterDeclaration) + } + if (!!node.decorators) { + node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) + } + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } + if (!!node.typeAnnotation) { + handleAstNode(node.typeAnnotation) + } + handleAnnotatedStatement(node) +} + +export function handleTSTypeAssertion(node: arkts.AstNode) { + if (!!node.getExpression) { + handleAstNode(node.getExpression) + } + if (!!node.typeAnnotation) { + handleAstNode(node.typeAnnotation) + } + handleAnnotatedExpression(node) +} + +export function handleTSTypeLiteral(node: arkts.AstNode) { + if (!!node.members) { + node.members.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + if (!!node.type) { + handleAstNode(node.type) + } + handleTypeNode(node) +} + +export function handleTSTypeOperator(node: arkts.AstNode) { + if (!!node.type) { + handleAstNode(node.type) + } + handleTypeNode(node) +} + +export function handleTSTypeParameter(node: arkts.AstNode) { + if (!!node.name) { + handleFunction(node.name, handleIdentifier) + } + if (!!node.constraint) { + handleAstNode(node.constraint) + } + if (!!node.defaultType) { + handleAstNode(node.defaultType) + } + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } + handleExpression(node) +} + +export function handleTSTypeParameterDeclaration(node: arkts.AstNode) { + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleFunction(item, handleTSTypeParameter)) + } + handleExpression(node) +} + +export function handleTSTypeParameterInstantiation(node: arkts.AstNode) { + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + handleExpression(node) +} + +export function handleTSTypePredicate(node: arkts.AstNode) { + if (!!node.parameterName) { + handleAstNode(node.parameterName) + } + if (!!node.typeAnnotation) { + handleAstNode(node.typeAnnotation) + } + handleTypeNode(node) +} + +export function handleTSTypeQuery(node: arkts.AstNode) { + if (!!node.exprName) { + handleAstNode(node.exprName) + } + handleTypeNode(node) +} + +export function handleTSTypeReference(node: arkts.AstNode) { + if (!!node.typeName) { + handleAstNode(node.typeName) + } + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterInstantiation) + } + handleTypeNode(node) +} + +export function handleTSUndefinedKeyword(node: arkts.AstNode) { + handleTypeNode(node) +} + +export function handleTSUnionType(node: arkts.AstNode) { + if (!!node.types) { + node.types.forEach((item: arkts.AstNode) => traverseProgram(item)) + } + handleTypeNode(node) +} + +export function handleTSUnknownKeyword(node: arkts.AstNode) { + handleTypeNode(node) +} + +export function handleTSVoidKeyword(node: arkts.AstNode) { + handleTypeNode(node) +} + +export function handleTaggedTemplateExpression(node: arkts.AstNode) { + if (!!node.tag) { + handleAstNode(node.tag) + } + if (!!node.quasi) { + handleFunction(node.quasi, handleTemplateLiteral) + } + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterInstantiation) + } + handleExpression(node) +} + +export function handleTemplateElement(node: arkts.AstNode) { + handleExpression(node) +} + +export function handleTemplateLiteral(node: arkts.AstNode) { + if (!!node.quasis) { + node.quasis.forEach((item: arkts.AstNode) => handleFunction(item, handleTemplateLiteral)) + } + if (!!node.expressions) { + node.expressions.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + handleExpression(node) +} + +export function handleThisExpression(node: arkts.AstNode) { + handleExpression(node) +} + +export function handleThrowStatement(node: arkts.AstNode) { + if (!!node.argument) { + handleAstNode(node.argument) + } + handleStatement(node) +} + +export function handleTryStatement(node: arkts.AstNode) { + if (!!node.finallyBlock) { + handleAstNode(node.finallyBlock) + } + if (!!node.block) { + handleAstNode(node.block) + } + if (!!node.catchClauses) { + node.catchClauses.forEach((item: arkts.AstNode) => handleFunction(item, handleCatchClause)) + } + handleStatement(node) +} + +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleTypeNode(node: arkts.AstNode) { + handleExpression(node) +} + +export function handleTypedAstNode(node: arkts.AstNode) { +} + +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleTypedStatement(node: arkts.AstNode) { + handleStatement(node) +} + +export function handleTypeofExpression(node: arkts.AstNode) { + if (!!node.argument) { + handleAstNode(node.argument) + } + handleExpression(node) +} + +export function handleUnaryExpression(node: arkts.AstNode) { + if (!!node.argument) { + handleAstNode(node.argument) + } + handleExpression(node) +} + +export function handleUndefinedLiteral(node: arkts.AstNode) { + handleLiteral(node) +} + +export function handleUpdateExpression(node: arkts.AstNode) { + if (!!node.argument) { + handleAstNode(node.argument) + } + handleExpression(node) +} + +export function handleValidationInfo(node: arkts.AstNode) { + return +} + +export function handleVariableDeclaration(node: arkts.AstNode) { + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } + if (!!node.declarators) { + node.declarators.forEach((item: arkts.AstNode) => handleFunction(item, handleVariableDeclarator)) + } + handleStatement(node) +} + +export function handleVariableDeclarator(node: arkts.AstNode) { + if (!!node.initializer) { + handleAstNode(node.initializer) + } + if (!!node.name) { + handleFunction(node.name, handleIdentifier) + } + handleTypedStatement(node) +} + +export function handleWhileStatement(node: arkts.AstNode) { + if (!!node.test) { + handleAstNode(node.test) + } + if (!!node.body) { + handleAstNode(node.body) + } + handleLoopStatement(node) +} + +export function handleYieldExpression(node: arkts.AstNode) { + if (!!node.argument) { + handleAstNode(node.argument) + } + handleExpression(node) +} -- Gitee From e5655c9a95d0bf53151eb67b2763cdbd016b3c42 Mon Sep 17 00:00:00 2001 From: w30045791 Date: Tue, 8 Jul 2025 19:43:43 +0800 Subject: [PATCH 2/2] wrapper and node_util Signed-off-by: w30045791 --- .../src/api_check_wrapper.ts | 100 ++-- .../utils/ts_wrapper_node_util.ts | 451 +++++++----------- 2 files changed, 237 insertions(+), 314 deletions(-) diff --git a/build-tools/compiler-plugins/api-check-plugin-static/api-check-wrapper/src/api_check_wrapper.ts b/build-tools/compiler-plugins/api-check-plugin-static/api-check-wrapper/src/api_check_wrapper.ts index fc6a1ff0bf..cf1b81bceb 100644 --- a/build-tools/compiler-plugins/api-check-plugin-static/api-check-wrapper/src/api_check_wrapper.ts +++ b/build-tools/compiler-plugins/api-check-plugin-static/api-check-wrapper/src/api_check_wrapper.ts @@ -13,13 +13,13 @@ * limitations under the License. */ -import * as arkts from '@koalaui/libarkts'; +import * as arkts from '@koalaui/libarkts' import { traverseProgram, getJSDocInformation } from '../utils/ts_wrapper_node_util' import { ApiCheckWrapperServiceHost, JsDocNodeCheckConfig, FileCheckModuleInfo, JSDoc, JSDocTag, JsDocNodeCheckConfigItem, CurrentAddress } from '../utils/api_check_wrapper_typedef' -import { SINCE_TAG_NAME } from "../../utils/api_check_plugin_define"; -import { parseCommand2JSDoc } from '../utils/api_check_wrapper_utils'; -export let curApiCheckWrapper: ApiCheckWrapper; -export let curFileCheckModuleInfo: FileCheckModuleInfo; +import { SINCE_TAG_NAME } from "../../utils/api_check_plugin_define" +import { parseCommand2JSDoc } from '../utils/api_check_wrapper_utils' +export let curApiCheckWrapper: ApiCheckWrapper +export let curFileCheckModuleInfo: FileCheckModuleInfo /** * 导出arkts命名空间 @@ -27,34 +27,39 @@ export let curFileCheckModuleInfo: FileCheckModuleInfo; export const WrapeprApi = { ...arkts } + +let checkedNode = new Map(); /** * 遍历节点树 * @param sourcefile */ export class ApiCheckWrapper { constructor(apiCheckHost: ApiCheckWrapperServiceHost) { - this.apiCheckHost = apiCheckHost; + this.apiCheckHost = apiCheckHost } setFileName(fileName: string) { - this.fileName = fileName; + this.fileName = fileName } - fileName: string; // ets源文件位置 + fileName: string // ets源文件位置 - sourcefile: string; // 声明节点位置 + sourcefile: string // 声明节点位置 - apiCheckHost: ApiCheckWrapperServiceHost; + apiCheckHost: ApiCheckWrapperServiceHost } export function checkApiExpression(apiCheckHost: ApiCheckWrapperServiceHost, peer: number | undefined) { + checkedNode = new Map() curApiCheckWrapper = new ApiCheckWrapper(apiCheckHost) curApiCheckWrapper.fileName = arkts.arktsGlobal.filePath + curFileCheckModuleInfo = {} as FileCheckModuleInfo curFileCheckModuleInfo.currentFileName = arkts.arktsGlobal.filePath + const contextPtr = arkts.arktsGlobal.compilerContext?.peer ?? peer // 获取当前ets文件路径，设置参数 if (!!contextPtr) { let program = arkts.getOrUpdateGlobalContext(contextPtr).program - let script = program.astNode; + let script = program.astNode // 获取根节点，开始遍历 traverseProgram(script) } @@ -65,16 +70,17 @@ export function checkApiExpression(apiCheckHost: ApiCheckWrapperServiceHost, pee * 处理identifier * @param node */ -export function checkIdntifier(node: arkts.AstNode) { - // 获取声明节点 +export function checkIdentifier(node: arkts.AstNode) { + // 获取校验节点的声明节点 const decl = arkts.getDecl(node) if (decl === undefined || decl === null) { console.log("debug decl error" + node.dumpJson()) return } + // 获取声明节点系统路径 let sysPath = getSysPath(decl) - curApiCheckWrapper.sourcefile = sysPath; + curApiCheckWrapper.sourcefile = sysPath if (sysPath === undefined || sysPath === null) { console.log("debug sysPath error :" + node.dumpJson()) @@ -84,27 +90,43 @@ export function checkIdntifier(node: arkts.AstNode) { if (!checkPram.nodeNeedCheck) { return } - // 如果是系统接口， 进入检查jsdoc流程 - expressionCheckByJsDoc(decl, node, curApiCheckWrapper.fileName, checkPram.checkConfig) + // 获取校验节点的行列信息 + const address = getCurrentAddressByNode(node) + if (confirmNodeChecked(node.name, address.line, address.column)) { + return + } + //进入检查jsdoc流程 + expressionCheckByJsDoc(decl, node, address, checkPram.checkConfig) +} + +function confirmNodeChecked(nodeName: string, line: number, col: number) { + let nodeKey = nodeName + "_" + line + "_" + col + if (checkedNode.has(nodeKey) && checkedNode.get(nodeKey) !== undefined) { + return true; + } else { + checkedNode.set(nodeKey, nodeName) + } } function getSysPath(decl: arkts.AstNode): string { // 获取节点的声明节点， let program = arkts.getProgramFromAstNode(decl) - return program.sourceFilePath } +/** + * 通过声明节点获取注释 + * @param decl 声明节点 + * @returns 注释信息 + */ export function getPeerJsDocs(decl: arkts.AstNde): string { return getJSDocInformation(decl) } - -function expressionCheckByJsDoc(declaration: arkts.AstNode, identifier: arkts.AstNode, sourceFile: string, checkConfig: JsDocNodeCheckConfigItem[]): void { +function expressionCheckByJsDoc(declaration: arkts.AstNode, identifier: arkts.AstNode, address: CurrentAddress, checkConfig: JsDocNodeCheckConfigItem[]): void { const jsDocsString = getPeerJsDocs(declaration) const jsDocs: JSDoc[] = parseCommand2JSDoc(jsDocsString) const jsDocTags = getCurrentJSDoc(jsDocs) - const address = getCurrentAddressByNode(identifier); for (let i = 0; i < checkConfig.length; i++) { const config = checkConfig[i] let tagNameExisted = false @@ -119,7 +141,7 @@ function expressionCheckByJsDoc(declaration: arkts.AstNode, identifier: arkts.As if (tagNameExisted && !config.tagNameShouldExisted) { curApiCheckWrapper.apiCheckHost.pushLogInfo(identifier.name, curApiCheckWrapper.fileName, address, config.type, config.message) } - }); + }) if (config.tagNameShouldExisted && !tagNameExisted) { curApiCheckWrapper.apiCheckHost.pushLogInfo(identifier.name, curApiCheckWrapper.fileName, address, config.type, config.message) } @@ -132,34 +154,38 @@ function expressionCheckByJsDoc(declaration: arkts.AstNode, identifier: arkts.As * @returns 节点行列信息 */ function getCurrentAddressByNode(node: arkts.AstNode): CurrentAddress { - let address = {} as CurrentAddress; - let startPostion = node.startPostion; - address.column = startPostion.index; - address.line = startPostion.line; - return address; + let address = {} as CurrentAddress + let startPosition = node.startPosition + address.column = startPosition.col() + address.line = startPosition.line() + 1 + return address } -/** Get Current JSDoc. */ +/** + * 获取最大的版本号 + * @param jsDocs + * @returns + */ function getCurrentJSDoc(jsDocs: JSDoc[]): JSDocTag[] { - let jsDocTags: JSDocTag[] = []; - let maxVersion: number = 0; + let jsDocTags: JSDocTag[] = [] + let maxVersion: number = 0 if (jsDocs && jsDocs.length > 0) { for (let i = 0; i < jsDocs.length; i++) { - const jsdoc: JSDoc = jsDocs[i]; + const jsdoc: JSDoc = jsDocs[i] if (jsdoc.tags && jsdoc.tags.length > 0) { for (let j = 0; j < jsdoc.tags.length; j++) { - const tag: JSDocTag = jsdoc.tags[j]; + const tag: JSDocTag = jsdoc.tags[j] if (tag.tag === SINCE_TAG_NAME) { - const currentVersion: number = Number.parseInt(tag.name); + const currentVersion: number = Number.parseInt(tag.name ?? "0") if (!Number.isNaN(currentVersion) && currentVersion > maxVersion) { - maxVersion = currentVersion; - jsDocTags = jsdoc.tags; + maxVersion = currentVersion + jsDocTags = jsdoc.tags } - break; + break } } } } } - return jsDocTags; -} + return jsDocTags +} \ No newline at end of file diff --git a/build-tools/compiler-plugins/api-check-plugin-static/api-check-wrapper/utils/ts_wrapper_node_util.ts b/build-tools/compiler-plugins/api-check-plugin-static/api-check-wrapper/utils/ts_wrapper_node_util.ts index 87dfe346b0..ec1a973528 100644 --- a/build-tools/compiler-plugins/api-check-plugin-static/api-check-wrapper/utils/ts_wrapper_node_util.ts +++ b/build-tools/compiler-plugins/api-check-plugin-static/api-check-wrapper/utils/ts_wrapper_node_util.ts @@ -1,20 +1,5 @@ import * as arkts from '@koalaui/libarkts'; -import { checkIdntifier } from "../src/api_check_wrapper" -export function traverseProgram(node: arkts.AstNode) { - // 处理Identifier - if (!!node.statements) { - node.statements.forEach((item: arkts.AstNode) => handleAstNode(item)) - } -} - -type NodeTuple = [string, number]; -const items: NodeTuple[] = []; -const isDebug = false; -const nodeMap = new Map(); - -export function getJSDocInformation(node: arkts.AstNode): string { - return arkts.classDefinitionJSDocInformation(node); -} +import { checkIdentifier } from "../src/api_check_wrapper" export const nodeHandleFunctionMap = new Map void>([ [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ASSIGNMENT_EXPRESSION, handleAssignmentExpression], @@ -172,23 +157,53 @@ export const nodeHandleFunctionMap = new Map void, isNeedAddPath?: boolean) { +export function traverseProgram(node: arkts.AstNode) { + // 处理Identifier + if (!!node.statements) { + node.statements.forEach((item: arkts.AstNode) => handleAstNode(item)) + } +} + +/** + * 获取Jsdoc信息 + * @param node 节点 + * @returns jsdoc 字符串 + */ +export function getJSDocInformation(node: arkts.AstNode): string { + return arkts.getJsdocStringFromDeclaration(node); +} + +/** + * + * @param node 节点 + * @param func 实际方法 + * @param checkRepeat + */ +function handleFunction(node: arkts.AstNode, func: (node: any, ...args: any[]) => void) { if (isDebug) { + items.push([func.name, node.peer.toString()]); console.log('[JSDOC_CHECK PLUGIN] ' + func.name); - if (isNeedAddPath) { - items.push([func.name, node.peer.toString()]); - } console.log("path: " + console.log(JSON.stringify(items))); } + // Expression 下的identifier才会提示告警 + if (node instanceof arkts.Expression) { + exporssionCount++; + } func(node); - if (isDebug && isNeedAddPath) { + if (isDebug) { if (nodeMap.has(node.peer.toString())) { if (nodeMap.get(node.peer.toString()) > 2) { console.error("[JSDOC_CHECK PLUGIN] repeat traverse") @@ -199,6 +214,9 @@ function handleFunction(node: arkts.AstNode, func: (node: any, ...args: any[]) = } items.pop(); } + if (node instanceof arkts.Expression) { + exporssionCount--; + } } export function handleAstNode(node: arkts.AstNode) { @@ -207,14 +225,13 @@ export function handleAstNode(node: arkts.AstNode) { } let kind: number = arkts.arktsGlobal.generatedEs2panda._AstNodeTypeConst(arkts.arktsGlobal.context, node.peer) if (nodeHandleFunctionMap.has(kind) && nodeHandleFunctionMap.get(kind) !== undefined) { - handleFunction(node, nodeHandleFunctionMap.get(kind)!, true) + handleFunction(node, nodeHandleFunctionMap.get(kind)!) } else { console.log("[JSDOC_CHECK PLUGIN] debug handleAstNode " + node.constructor.name + " error!") } } -export function handleAnnotatedAstNode(node: arkts.AstNode) { -} +export function handleAnnotatedAstNode(node: arkts.AstNode) { } /** * * @param node 当前节点 @@ -225,12 +242,9 @@ export function handleAnnotatedExpression(node: arkts.AstNode) { if (!!node.typeAnnotation) { handleAstNode(node.typeAnnotation) } - handleExpression(node) } -export function handleAnnotatedStatement(node: arkts.AstNode) { - handleStatement(node) -} +export function handleAnnotatedStatement(node: arkts.AstNode) { } export function handleAnnotationDeclaration(node: arkts.AstNode) { if (!!node.expr) { @@ -242,7 +256,6 @@ export function handleAnnotationDeclaration(node: arkts.AstNode) { if (!!node.annotations) { node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) } - handleStatement(node) } export function handleAnnotationUsage(node: arkts.AstNode) { @@ -252,7 +265,6 @@ export function handleAnnotationUsage(node: arkts.AstNode) { if (!!node.properties) { node.properties.forEach((item: arkts.AstNode) => handleAstNode(item)) } - handleStatement(node) } export function handleArrayExpression(node: arkts.AstNode) { @@ -265,7 +277,6 @@ export function handleArrayExpression(node: arkts.AstNode) { if (!!node.typeAnnotation) { handleAstNode(node.typeAnnotation) } - handleAnnotatedExpression(node) } export function handleArrowFunctionExpression(node: arkts.AstNode) { @@ -275,7 +286,6 @@ export function handleArrowFunctionExpression(node: arkts.AstNode) { if (!!node.scriptFunction) { handleAstNode(node.scriptFunction) } - handleExpression(node) } export function handleAssertStatement(node: arkts.AstNode) { @@ -285,7 +295,6 @@ export function handleAssertStatement(node: arkts.AstNode) { if (!!node.second) { handleAstNode(node.second) } - handleStatement(node) } export function handleAssignmentExpression(node: arkts.AstNode) { @@ -295,7 +304,6 @@ export function handleAssignmentExpression(node: arkts.AstNode) { if (!!node.right) { handleAstNode(node.right) } - handleExpression(node) } export function handleAstDumper(node: arkts.AstNode) { @@ -306,12 +314,9 @@ export function handleAwaitExpression(node: arkts.AstNode) { if (!!node.argument) { handleAstNode(node.argument) } - handleExpression(node) } -export function handleBigIntLiteral(node: arkts.AstNode) { - handleLiteral(node) -} +export function handleBigIntLiteral(node: arkts.AstNode) { } export function handleBinaryExpression(node: arkts.AstNode) { if (!!node.left) { @@ -323,14 +328,12 @@ export function handleBinaryExpression(node: arkts.AstNode) { if (!!node.result) { handleAstNode(node.result) } - handleExpression(node) } export function handleBlockExpression(node: arkts.AstNode) { if (!!node.statements) { node.statements.forEach((item: arkts.AstNode) => handleAstNode(item)) } - handleExpression(node) } /** @@ -343,12 +346,9 @@ export function handleBlockStatement(node: arkts.AstNode) { if (!!node.statements) { node.statements.forEach((item: arkts.AstNode) => handleAstNode(item)) } - handleStatement(node) } -export function handleBooleanLiteral(node: arkts.AstNode) { - handleLiteral(node) -} +export function handleBooleanLiteral(node: arkts.AstNode) { } export function handleBreakStatement(node: arkts.AstNode) { if (!!node.ident) { @@ -357,7 +357,6 @@ export function handleBreakStatement(node: arkts.AstNode) { if (!!node.target) { handleAstNode(node.target) } - handleStatement(node) } export function handleCallExpression(node: arkts.AstNode) { @@ -376,7 +375,6 @@ export function handleCallExpression(node: arkts.AstNode) { if (!!node.params) { node.params.forEach((item: arkts.TypeNode) => handleAstNode(item)) } - handleExpression(node) } export function handleCatchClause(node: arkts.AstNode) { @@ -386,19 +384,15 @@ export function handleCatchClause(node: arkts.AstNode) { if (!!node.body) { handleAstNode(node.body) } - handleTypedStatement(node) } export function handleChainExpression(node: arkts.AstNode) { if (!!node.getExpression) { handleAstNode(node.getExpression) } - handleExpression(node) } -export function handleCharLiteral(node: arkts.AstNode) { - handleLiteral(node) -} +export function handleCharLiteral(node: arkts.AstNode) { } export function handleClassDeclaration(node: arkts.AstNode) { if (!!node.definition) { @@ -407,7 +401,6 @@ export function handleClassDeclaration(node: arkts.AstNode) { if (!!node.decorators) { node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) } - handleStatement(node) } export function handleClassDefinition(node: arkts.AstNode) { @@ -435,7 +428,6 @@ export function handleClassDefinition(node: arkts.AstNode) { if (!!node.getAnonClass) { handleAstNode(node.getAnonClass) } - handleTypedAstNode(node) } /** @@ -454,14 +446,12 @@ export function handleClassElement(node: arkts.AstNode) { if (!!node.decorators) { node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) } - handleTypedStatement(node) } export function handleClassExpression(node: arkts.AstNode) { if (!!node.definition) { handleFunction(node.definition, handleClassDefinition) } - handleExpression(node) } export function handleClassProperty(node: arkts.AstNode) { @@ -471,12 +461,9 @@ export function handleClassProperty(node: arkts.AstNode) { if (!!node.annotations) { node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) } - handleClassElement(node) } -export function handleClassStaticBlock(node: arkts.AstNode) { - handleClassElement(node) -} +export function handleClassStaticBlock(node: arkts.AstNode) { } export function handleConditionalExpression(node: arkts.AstNode) { if (!!node.test) { @@ -488,35 +475,44 @@ export function handleConditionalExpression(node: arkts.AstNode) { if (!!node.alternate) { handleAstNode(node.alternate) } - handleExpression(node) } -export function handleContext(node: arkts.AstNode) { -} +export function handleContext(node: arkts.AstNode) { } +/** + * target重复节点，不遍历 + * @param node + */ export function handleContinueStatement(node: arkts.AstNode) { if (!!node.ident) { handleFunction(node.ident, handleIdentifier) } - if (!!node.target) { - handleAstNode(node.target) - } - handleStatement(node) } -export function handleDebuggerStatement(node: arkts.AstNode) { - handleStatement(node) -} +export function handleDebuggerStatement(node: arkts.AstNode) { } export function handleDecorator(node: arkts.AstNode) { if (!!node.expr) { handleAstNode(node.expr) } - handleStatement(node) } export function handleDirectEvalExpression(node: arkts.AstNode) { - handleCallExpression(node) + if (!!node.trailingBlock) { + handleAstNode(node.trailingBlock) + } + if (!!node.expression) { + handleAstNode(node.expression) + } + if (!!node.typeArguments) { + node.typeArguments.forEach((item: arkts.TypeNode) => handleAstNode(item)) + } + if (!!node.arguments) { + node.arguments.forEach((item: arkts.Expression) => handleAstNode(item)) + } + if (!!node.params) { + node.params.forEach((item: arkts.TypeNode) => handleAstNode(item)) + } } export function handleDoWhileStatement(node: arkts.AstNode) { @@ -526,18 +522,27 @@ export function handleDoWhileStatement(node: arkts.AstNode) { if (!!node.body) { handleAstNode(node.body) } - handleLoopStatement(node) } export function handleETSClassLiteral(node: arkts.AstNode) { if (!!node.expr) { handleAstNode(node.expr) } - handleExpression(node) } export function handleETSDynamicFunctionType(node: arkts.AstNode) { - handleETSFunctionType(node) + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterDeclaration) + } + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + if (!!node.returnType) { + handleAstNode(node.returnType) + } + if (!!node.functionInterface) { + handleAstNode(node.functionInterface) + } } /** @@ -559,12 +564,9 @@ export function handleETSFunctionType(node: arkts.AstNode) { if (!!node.functionInterface) { handleAstNode(node.functionInterface) } - handleTypeNode(node) } -export function handleETSImportDeclaration(node: arkts.AstNode) { - handleImportDeclaration(node) -} +export function handleETSImportDeclaration(node: arkts.AstNode) { } export function handleETSModule(node: arkts.AstNode) { if (!!node.ident) { @@ -573,7 +575,9 @@ export function handleETSModule(node: arkts.AstNode) { if (!!node.annotations) { node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) } - handleBlockStatement(node) + if (!!node.statements) { + node.statements.forEach((item: arkts.AstNode) => handleAstNode(item)) + } } export function handleETSNewArrayInstanceExpression(node: arkts.AstNode) { @@ -583,7 +587,6 @@ export function handleETSNewArrayInstanceExpression(node: arkts.AstNode) { if (!!node.dimension) { handleAstNode(node.dimension) } - handleExpression(node) } export function handleETSNewClassInstanceExpression(node: arkts.AstNode) { @@ -593,7 +596,6 @@ export function handleETSNewClassInstanceExpression(node: arkts.AstNode) { if (!!node.getArgments) { node.getArgments.forEach((item: arkts.AstNode) => handleAstNode(item)) } - handleExpression(node) } export function handleETSNewMultiDimArrayInstanceExpression(node: arkts.AstNode) { @@ -603,16 +605,11 @@ export function handleETSNewMultiDimArrayInstanceExpression(node: arkts.AstNode) if (!!node.typeReference) { handleAstNode(node.typeReference) } - handleExpression(node) } -export function handleETSNullType(node: arkts.AstNode) { - handleTypeNode(node) -} +export function handleETSNullType(node: arkts.AstNode) { } -export function handleETSPackageDeclaration(node: arkts.AstNode) { - handleStatement(node) -} +export function handleETSPackageDeclaration(node: arkts.AstNode) { } export function handleETSParameterExpression(node: arkts.AstNode) { if (!!node.annotations) { @@ -627,36 +624,36 @@ export function handleETSParameterExpression(node: arkts.AstNode) { if (!!node.identifier) { handleFunction(node.identifier, handleIdentifier) } - handleExpression(node) } export function handleETSPrimitiveType(node: arkts.AstNode) { - handleTypeNode(node) } export function handleETSReExportDeclaration(node: arkts.AstNode) { if (!!node.getETSImportDeclarations) { handleFunction(node.getETSImportDeclarations, handleETSImportDeclaration) } - handleStatement(node) } export function handleETSStructDeclaration(node: arkts.AstNode) { - handleClassDeclaration(node) + if (!!node.definition) { + handleFunction(node.definition, handleClassDefinition) + } + if (!!node.decorators) { + node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) + } } export function handleETSTuple(node: arkts.AstNode) { if (!!node.getTupleTypeAnnotationsList) { node.getTupleTypeAnnotationsList.forEach((item: arkts.AstNde) => handleAstNode(item)) } - handleTypeNode(node) } export function handleETSTypeReference(node: arkts.AstNode) { if (!!node.part) { handleFunction(node.part, handleETSTypeReferencePart) } - handleTypeNode(node) } export function handleETSTypeReferencePart(node: arkts.AstNode) { @@ -669,30 +666,23 @@ export function handleETSTypeReferencePart(node: arkts.AstNode) { if (!!node.typeParams) { handleFunction(node.typeParams, handleTSTypeParameterInstantiation) } - handleTypeNode(node) } -export function handleETSUndefinedType(node: arkts.AstNode) { - handleTypeNode(node) -} +export function handleETSUndefinedType(node: arkts.AstNode) { } export function handleETSUnionType(node: arkts.AstNode) { if (!!node.types) { node.types.forEach((item: arkts.AstNde) => handleAstNode(item)) } - handleTypeNode(node) } export function handleETSWildcardType(node: arkts.AstNode) { if (!!node.typeReference) { handleFunction(node.typeReference, handleETSTypeReference) } - handleTypeNode(node) } -export function handleEmptyStatement(node: arkts.AstNode) { - handleStatement(node) -} +export function handleEmptyStatement(node: arkts.AstNode) { } export function handleExportAllDeclaration(node: arkts.AstNode) { if (!!node.source) { @@ -701,14 +691,12 @@ export function handleExportAllDeclaration(node: arkts.AstNode) { if (!!node.exported) { handleFunction(node.exported, handleIdentifier) } - handleStatement(node) } export function handleExportDefaultDeclaration(node: arkts.AstNode) { if (!!node.decl) { handleAstNode(node.decl) } - handleStatement(node) } export function handleExportNamedDeclaration(node: arkts.AstNode) { @@ -721,7 +709,6 @@ export function handleExportNamedDeclaration(node: arkts.AstNode) { if (!!node.specifiers) { node.specifiers.forEach((item: arkts.AstNode) => handleFunction(item, handleExportSpecifier)) } - handleStatement(node) } export function handleExportSpecifier(node: arkts.AstNode) { @@ -731,7 +718,6 @@ export function handleExportSpecifier(node: arkts.AstNode) { if (!!node.exported) { handleFunction(node.exported, handleIdentifier) } - handleStatement(node) } /** @@ -739,14 +725,12 @@ export function handleExportSpecifier(node: arkts.AstNode) { * @param node 当前节点 * @param isTypeConfirmed 是否已确认类型 */ -export function handleExpression(node: arkts.AstNode) { -} +export function handleExpression(node: arkts.AstNode) { } export function handleExpressionStatement(node: arkts.AstNode) { if (!!node.expression) { handleAstNode(node.expression) } - handleStatement(node) } export function handleForInStatement(node: arkts.AstNode) { @@ -759,7 +743,6 @@ export function handleForInStatement(node: arkts.AstNode) { if (!!node.body) { handleAstNode(node.body) } - handleLoopStatement(node) } export function handleForOfStatement(node: arkts.AstNode) { @@ -772,7 +755,6 @@ export function handleForOfStatement(node: arkts.AstNode) { if (!!node.body) { handleAstNode(node.body) } - handleLoopStatement(node) } export function handleForUpdateStatement(node: arkts.AstNode) { @@ -788,11 +770,30 @@ export function handleForUpdateStatement(node: arkts.AstNode) { if (!!node.body) { handleAstNode(node.body) } - handleLoopStatement(node) } export function handleFunctionDecl(node: arkts.AstNode) { - handleScriptFunction(node) + if (!!node.id) { + handleFunction(node.id, handleIdentifier) + } + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + if (!!node.returnStatements) { + node.returnStatements.forEach((item: arkts.AstNode) => handleFunction(item, handleReturnStatement)) + } + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterDeclaration) + } + if (!!node.body) { + handleAstNode(node.body) + } + if (!!node.returnTypeAnnotation) { + handleAstNode(node.returnTypeAnnotation) + } + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNde) => handleFunction(item, handleAnnotationUsage)) + } } export function handleFunctionDeclaration(node: arkts.AstNode) { @@ -817,14 +818,13 @@ export function handleFunctionDeclaration(node: arkts.AstNode) { if (!!node.returnType) { handleAstNode(node.returnType) } - handleStatement(node) } export function handleFunctionExpression(node: arkts.AstNode) { if (!!node.scriptFunction) { handleAstNode(node.scriptFunction) } - handleExpression(node) + } export function handleFunctionSignature(node: arkts.AstNode) { @@ -840,7 +840,9 @@ export function handleFunctionSignature(node: arkts.AstNode) { } export function handleIdentifier(node: arkts.AstNode) { - checkIdntifier(node); + if (exporssionCount > 1) { + checkIdentifier(node); + } if (!!node.decorators) { node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) @@ -848,7 +850,6 @@ export function handleIdentifier(node: arkts.AstNode) { if (!!node.typeAnnotation) { handleAstNode(node.typeAnnotation) } - handleAnnotatedExpression(node) } export function handleIfStatement(node: arkts.AstNode) { @@ -861,7 +862,6 @@ export function handleIfStatement(node: arkts.AstNode) { if (!!node.alternate) { handleAstNode(node.alternate) } - handleStatement(node) } /** * import节点 不处理Identifier @@ -876,21 +876,19 @@ export function handleImportDefaultSpecifier(node: arkts.AstNode) { if (!!node.local) { handleFunction(node.local, handleIdentifier) } - handleStatement(node) } export function handleImportExpression(node: arkts.AstNode) { if (!!node.source) { handleFunction(node.source, handleStringLiteral) } - handleExpression(node) } export function handleImportNamespaceSpecifier(node: arkts.AstNode) { if (!!node.local) { handleFunction(node.local, handleIdentifier) } - handleStatement(node) + } export function handleImportSource(node: arkts.AstNode) { @@ -909,11 +907,31 @@ export function handleImportSpecifier(node: arkts.AstNode) { if (!!node.local) { handleFunction(node.local, handleIdentifier) } - handleStatement(node) + } export function handleInterfaceDecl(node: arkts.AstNode) { - handleTSInterfaceDeclaration(node) + if (!!node.id) { + handleFunction(node.id, handleIdentifier) + } + if (!!node.body) { + handleFunction(node.body, handleTSInterfaceBody) + } + if (!!node.typeParams) { + handleFunction(node.typeParam, handleTSTypeParameterDeclaration) + } + if (!!node.extends) { + node.extends.forEach((item: arkts.TypeNode) => handleFunction(item, handleTSInterfaceHeritage)) + } + if (!!node.decorators) { + node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) + } + if (!!node.getAnonClass) { + handleAstNode(node.getAnonClass) + } + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } } export function handleLabelPair(node: arkts.AstNode) { @@ -925,31 +943,23 @@ export function handleLabelPair(node: arkts.AstNode) { } } -export function handleLabelledStatement(node: arkts.AstNode) { - handleStatement(node) -} +export function handleLabelledStatement(node: arkts.AstNode) { } /** * * @param node 当前节点 * @param isTypeConfirmed 是否已确认类型 * @returns */ -export function handleLiteral(node: arkts.AstNode) { - handleExpression(node) -} +export function handleLiteral(node: arkts.AstNode) { } /** * * @param node 当前节点 * @param isTypeConfirmed 是否已确认类型 * @returns */ -export function handleLoopStatement(node: arkts.AstNode) { - handleStatement(node) -} +export function handleLoopStatement(node: arkts.AstNode) { } -export function handleMaybeOptionalExpression(node: arkts.AstNode) { - handleExpression(node) -} +export function handleMaybeOptionalExpression(node: arkts.AstNode) { } export function handleMemberExpression(node: arkts.AstNode) { if (!!node.object) { @@ -958,12 +968,9 @@ export function handleMemberExpression(node: arkts.AstNode) { if (!!node.property) { handleAstNode(node.property) } - handleExpression(node) } -export function handleMetaProperty(node: arkts.AstNode) { - handleExpression(node) -} +export function handleMetaProperty(node: arkts.AstNode) { } export function handleMethodDefinition(node: arkts.AstNode) { if (!!node.overloads) { @@ -975,7 +982,6 @@ export function handleMethodDefinition(node: arkts.AstNode) { if (!!node.name) { handleFunction(node.name, handleIdentifier) } - handleClassElement(node) } export function handleNamedType(node: arkts.AstNode) { @@ -985,7 +991,6 @@ export function handleNamedType(node: arkts.AstNode) { if (!!node.typeParams) { handleFunction(node.typeParams, handleTSTypeParameterInstantiation) } - handleTypeNode(node) } export function handleNewExpression(node: arkts.AstNode) { @@ -995,16 +1000,11 @@ export function handleNewExpression(node: arkts.AstNode) { if (!!node.arguments) { node.arguments.forEach((item: arkts.AstNode) => handleAstNode(item)) } - handleExpression(node) } -export function handleNullLiteral(node: arkts.AstNode) { - handleLiteral(node) -} +export function handleNullLiteral(node: arkts.AstNode) { } -export function handleNumberLiteral(node: arkts.AstNode) { - handleLiteral(node) -} +export function handleNumberLiteral(node: arkts.AstNode) { } export function handleObjectExpression(node: arkts.AstNode) { if (!!node.properties) { @@ -1016,16 +1016,11 @@ export function handleObjectExpression(node: arkts.AstNode) { if (!!node.typeAnnotation) { handleAstNode(node.typeAnnotation) } - handleAnnotatedExpression(node) } -export function handleOmittedExpression(node: arkts.AstNode) { - handleExpression(node) -} +export function handleOmittedExpression(node: arkts.AstNode) { } -export function handleOpaqueTypeNode(node: arkts.AstNode) { - handleTypeNode(node) -} +export function handleOpaqueTypeNode(node: arkts.AstNode) { } export function handlePrefixAssertionExpression(node: arkts.AstNode) { if (!!node.expr) { @@ -1034,7 +1029,6 @@ export function handlePrefixAssertionExpression(node: arkts.AstNode) { if (!!node.type) { handleAstNode(node.type) } - handleExpression(node) } export function handleProperty(node: arkts.AstNode) { @@ -1044,18 +1038,14 @@ export function handleProperty(node: arkts.AstNode) { if (!!node.value) { handleAstNode(node.value) } - handleExpression(node) } -export function handleRegExpLiteral(node: arkts.AstNode) { - handleLiteral(node) -} +export function handleRegExpLiteral(node: arkts.AstNode) { } export function handleReturnStatement(node: arkts.AstNode) { if (!!node.argument) { handleAstNode(node.argument) } - handleStatement(node) } export function handleScriptFunction(node: arkts.AstNode) { @@ -1086,7 +1076,6 @@ export function handleSequenceExpression(node: arkts.AstNode) { if (!!node.sequence) { node.sequence.forEach((item: arkts.AstNode) => handleAstNode(item)) } - handleExpression(node) } export function handleSpreadElement(node: arkts.AstNode) { @@ -1099,7 +1088,6 @@ export function handleSpreadElement(node: arkts.AstNode) { if (!!node.typeAnnotation) { handleAstNode(node.typeAnnotation) } - handleAnnotatedExpression(node) } export function handleSrcDumper(node: arkts.AstNode) { @@ -1113,15 +1101,12 @@ export function handleSrcDumper(node: arkts.AstNode) { export function handleStatement(node: arkts.AstNode) { } -export function handleStringLiteral(node: arkts.AstNode) { - handleLiteral(node) -} +export function handleStringLiteral(node: arkts.AstNode) { } export function handleSuperExpression(node: arkts.AstNode) { if (!!node.id) { handleFunction(node.id, handleIdentifier) } - handleExpression(node) } export function handleSwitchCaseStatement(node: arkts.AstNode) { @@ -1131,7 +1116,6 @@ export function handleSwitchCaseStatement(node: arkts.AstNode) { if (!!node.consequent) { node.consequent.forEach((item: arkts.AstNode) => handleAstNode(item)) } - handleStatement(node) } export function handleSwitchStatement(node: arkts.AstNode) { @@ -1141,11 +1125,9 @@ export function handleSwitchStatement(node: arkts.AstNode) { if (!!node.cases) { node.cases.forEach((item: arkts.AstNode) => handleFunction(item, handleSwitchCaseStatement)) } - handleStatement(node) } export function handleTSAnyKeyword(node: arkts.AstNode) { - handleTypeNode(node) } export function handleTSArrayType(node: arkts.AstNode) { @@ -1161,16 +1143,11 @@ export function handleTSAsExpression(node: arkts.AstNode) { if (!!node.typeAnnotation) { handleAstNode(node.typeAnnotation) } - handleAnnotatedExpression(node) } -export function handleTSBigintKeyword(node: arkts.AstNode) { - handleTypeNode(node) -} +export function handleTSBigintKeyword(node: arkts.AstNode) { } -export function handleTSBooleanKeyword(node: arkts.AstNode) { - handleTypeNode(node) -} +export function handleTSBooleanKeyword(node: arkts.AstNode) { } export function handleTSClassImplements(node: arkts.AstNode) { if (!!node.expr) { @@ -1179,7 +1156,6 @@ export function handleTSClassImplements(node: arkts.AstNode) { if (!!node.typeParameters) { handleFunction(node.typeParameters, handleTSTypeParameterInstantiation) } - handleExpression(node) } export function handleTSConditionalType(node: arkts.AstNode) { @@ -1195,7 +1171,6 @@ export function handleTSConditionalType(node: arkts.AstNode) { if (!!node.falseType) { handleAstNode(node.falseType) } - handleTypeNode(node) } export function handleTSConstructorType(node: arkts.AstNode) { @@ -1208,7 +1183,6 @@ export function handleTSConstructorType(node: arkts.AstNode) { if (!!node.returnType) { handleAstNode(node.returnType) } - handleTypeNode(node) } export function handleTSEnumDeclaration(node: arkts.AstNode) { @@ -1224,7 +1198,6 @@ export function handleTSEnumDeclaration(node: arkts.AstNode) { if (!!node.decorators) { node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) } - handleTypedStatement(node) } export function handleTSEnumMember(node: arkts.AstNode) { @@ -1234,14 +1207,12 @@ export function handleTSEnumMember(node: arkts.AstNode) { if (!!node.init) { handleAstNode(node.init) } - handleStatement(node) } export function handleTSExternalModuleReference(node: arkts.AstNode) { if (!!node.expr) { handleAstNode(node.expr) } - handleExpression(node) } export function handleTSFunctionType(node: arkts.AstNode) { @@ -1254,7 +1225,6 @@ export function handleTSFunctionType(node: arkts.AstNode) { if (!!node.returnType) { handleAstNode(node.returnType) } - handleTypeNode(node) } export function handleTSImportEqualsDeclaration(node: arkts.AstNode) { @@ -1264,7 +1234,6 @@ export function handleTSImportEqualsDeclaration(node: arkts.AstNode) { if (!!node.moduleReference) { handleAstNode(node.moduleReference) } - handleStatement(node) } export function handleTSImportType(node: arkts.AstNode) { @@ -1277,7 +1246,6 @@ export function handleTSImportType(node: arkts.AstNode) { if (!!node.qualifier) { handleAstNode(node.qualifier) } - handleTypeNode(node) } export function handleTSIndexSignature(node: arkts.AstNode) { @@ -1287,7 +1255,6 @@ export function handleTSIndexSignature(node: arkts.AstNode) { if (!!node.indexType) { handleAstNode(node.indexType) } - handleTypeNode(node) } export function handleTSIndexedAccessType(node: arkts.AstNode) { @@ -1297,21 +1264,18 @@ export function handleTSIndexedAccessType(node: arkts.AstNode) { if (!!node.typeAnnotation) { handleAstNode(node.typeAnnotation) } - handleTypedAstNode(node) } export function handleTSInferType(node: arkts.AstNode) { if (!!node.typeParam) { handleFunction(node.typeParam, handleTSTypeParameter) } - handleTypeNode(node) } export function handleTSInterfaceBody(node: arkts.AstNode) { if (!!node.body) { node.body.forEach((item: arkts.TypeNode) => handleAstNode(item)) } - handleExpression(node) } export function handleTSInterfaceDeclaration(node: arkts.AstNode) { @@ -1336,28 +1300,24 @@ export function handleTSInterfaceDeclaration(node: arkts.AstNode) { if (!!node.annotations) { node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) } - handleTypedStatement(node) } export function handleTSInterfaceHeritage(node: arkts.AstNode) { if (!!node.expr) { handleAstNode(node.expr) } - handleExpression(node) } export function handleTSIntersectionType(node: arkts.AstNode) { if (!!node.types) { node.types.forEach((item: arkts.AstNode) => handleAstNode(item)) } - handleTypeNode(node) } export function handleTSLiteralType(node: arkts.AstNode) { if (!!node.literal) { handleAstNode(node.literal) } - handleTypeNode(node) } export function handleTSMappedType(node: arkts.AstNode) { @@ -1367,7 +1327,6 @@ export function handleTSMappedType(node: arkts.AstNode) { if (!!node.typeAnnotation) { handleAstNode(node.typeAnnotation) } - handleTypeNode(node) } export function handleTSMethodSignature(node: arkts.AstNode) { @@ -1389,7 +1348,6 @@ export function handleTSModuleBlock(node: arkts.AstNode) { if (!!node.statements) { node.statements.forEach((item: arkts.AstNode) => handleAstNode(item)) } - handleStatement(node) } export function handleTSModuleDeclaration(node: arkts.AstNode) { @@ -1399,7 +1357,6 @@ export function handleTSModuleDeclaration(node: arkts.AstNode) { if (!!node.body) { handleAstNode(node.body) } - handleStatement(node) } export function handleTSNamedTupleMember(node: arkts.AstNode) { @@ -1409,44 +1366,32 @@ export function handleTSNamedTupleMember(node: arkts.AstNode) { if (!!node.elementType) { handleAstNode(node.elementType) } - handleTypeNode(node) } -export function handleTSNeverKeyword(node: arkts.AstNode) { - handleTypeNode(node) -} +export function handleTSNeverKeyword(node: arkts.AstNode) { } export function handleTSNonNullExpression(node: arkts.AstNode) { if (!!node.expr) { handleAstNode(node.expr) } - handleExpression(node) } -export function handleTSNullKeyword(node: arkts.AstNode) { - handleTypeNode(node) -} +export function handleTSNullKeyword(node: arkts.AstNode) { } -export function handleTSNumberKeyword(node: arkts.AstNode) { - handleTypeNode(node) -} +export function handleTSNumberKeyword(node: arkts.AstNode) { } -export function handleTSObjectKeyword(node: arkts.AstNode) { - handleTypeNode(node) -} +export function handleTSObjectKeyword(node: arkts.AstNode) { } export function handleTSParameterProperty(node: arkts.AstNode) { if (!!node.parameter) { handleAstNode(node.parameter) } - handleExpression(node) } export function handleTSParenthesizedType(node: arkts.AstNode) { if (!!node.type) { handleAstNode(node.type) } - handleTypeNode(node) } export function handleTSPropertySignature(node: arkts.AstNode) { @@ -1456,7 +1401,6 @@ export function handleTSPropertySignature(node: arkts.AstNode) { if (!!node.typeAnnotation) { handleAstNode(node.typeAnnotation) } - handleAnnotatedAstNode(node) } export function handleTSQualifiedName(node: arkts.AstNode) { @@ -1466,7 +1410,6 @@ export function handleTSQualifiedName(node: arkts.AstNode) { if (!!node.right) { handleFunction(node.right, handleIdentifier) } - handleExpression(node) } export function handleTSSignatureDeclaration(node: arkts.AstNode) { @@ -1479,22 +1422,16 @@ export function handleTSSignatureDeclaration(node: arkts.AstNode) { if (!!node.returnTypeAnnotation) { handleAstNode(node.returnTypeAnnotation) } - handleTypedAstNode(node) } -export function handleTSStringKeyword(node: arkts.AstNode) { - handleTypeNode(node) -} +export function handleTSStringKeyword(node: arkts.AstNode) { } -export function handleTSThisType(node: arkts.AstNode) { - handleTypeNode(node) -} +export function handleTSThisType(node: arkts.AstNode) { } export function handleTSTupleType(node: arkts.AstNode) { if (!!node.elementType) { node.elementType.forEach((item: arkts.AstNode) => handleAstNode(item)) } - handleTypeNode(node) } export function handleTSTypeAliasDeclaration(node: arkts.AstNode) { @@ -1513,7 +1450,6 @@ export function handleTSTypeAliasDeclaration(node: arkts.AstNode) { if (!!node.typeAnnotation) { handleAstNode(node.typeAnnotation) } - handleAnnotatedStatement(node) } export function handleTSTypeAssertion(node: arkts.AstNode) { @@ -1523,7 +1459,7 @@ export function handleTSTypeAssertion(node: arkts.AstNode) { if (!!node.typeAnnotation) { handleAstNode(node.typeAnnotation) } - handleAnnotatedExpression(node) + } export function handleTSTypeLiteral(node: arkts.AstNode) { @@ -1533,14 +1469,12 @@ export function handleTSTypeLiteral(node: arkts.AstNode) { if (!!node.type) { handleAstNode(node.type) } - handleTypeNode(node) } export function handleTSTypeOperator(node: arkts.AstNode) { if (!!node.type) { handleAstNode(node.type) } - handleTypeNode(node) } export function handleTSTypeParameter(node: arkts.AstNode) { @@ -1556,21 +1490,18 @@ export function handleTSTypeParameter(node: arkts.AstNode) { if (!!node.annotations) { node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) } - handleExpression(node) } export function handleTSTypeParameterDeclaration(node: arkts.AstNode) { if (!!node.params) { node.params.forEach((item: arkts.AstNode) => handleFunction(item, handleTSTypeParameter)) } - handleExpression(node) } export function handleTSTypeParameterInstantiation(node: arkts.AstNode) { if (!!node.params) { node.params.forEach((item: arkts.AstNode) => handleAstNode(item)) } - handleExpression(node) } export function handleTSTypePredicate(node: arkts.AstNode) { @@ -1580,14 +1511,12 @@ export function handleTSTypePredicate(node: arkts.AstNode) { if (!!node.typeAnnotation) { handleAstNode(node.typeAnnotation) } - handleTypeNode(node) } export function handleTSTypeQuery(node: arkts.AstNode) { if (!!node.exprName) { handleAstNode(node.exprName) } - handleTypeNode(node) } export function handleTSTypeReference(node: arkts.AstNode) { @@ -1597,27 +1526,19 @@ export function handleTSTypeReference(node: arkts.AstNode) { if (!!node.typeParams) { handleFunction(node.typeParams, handleTSTypeParameterInstantiation) } - handleTypeNode(node) } -export function handleTSUndefinedKeyword(node: arkts.AstNode) { - handleTypeNode(node) -} +export function handleTSUndefinedKeyword(node: arkts.AstNode) { } export function handleTSUnionType(node: arkts.AstNode) { if (!!node.types) { node.types.forEach((item: arkts.AstNode) => traverseProgram(item)) } - handleTypeNode(node) } -export function handleTSUnknownKeyword(node: arkts.AstNode) { - handleTypeNode(node) -} +export function handleTSUnknownKeyword(node: arkts.AstNode) { } -export function handleTSVoidKeyword(node: arkts.AstNode) { - handleTypeNode(node) -} +export function handleTSVoidKeyword(node: arkts.AstNode) { } export function handleTaggedTemplateExpression(node: arkts.AstNode) { if (!!node.tag) { @@ -1629,12 +1550,9 @@ export function handleTaggedTemplateExpression(node: arkts.AstNode) { if (!!node.typeParams) { handleFunction(node.typeParams, handleTSTypeParameterInstantiation) } - handleExpression(node) } -export function handleTemplateElement(node: arkts.AstNode) { - handleExpression(node) -} +export function handleTemplateElement(node: arkts.AstNode) { } export function handleTemplateLiteral(node: arkts.AstNode) { if (!!node.quasis) { @@ -1643,18 +1561,14 @@ export function handleTemplateLiteral(node: arkts.AstNode) { if (!!node.expressions) { node.expressions.forEach((item: arkts.AstNode) => handleAstNode(item)) } - handleExpression(node) } -export function handleThisExpression(node: arkts.AstNode) { - handleExpression(node) -} +export function handleThisExpression(node: arkts.AstNode) { } export function handleThrowStatement(node: arkts.AstNode) { if (!!node.argument) { handleAstNode(node.argument) } - handleStatement(node) } export function handleTryStatement(node: arkts.AstNode) { @@ -1667,7 +1581,6 @@ export function handleTryStatement(node: arkts.AstNode) { if (!!node.catchClauses) { node.catchClauses.forEach((item: arkts.AstNode) => handleFunction(item, handleCatchClause)) } - handleStatement(node) } /** @@ -1676,12 +1589,9 @@ export function handleTryStatement(node: arkts.AstNode) { * @param isTypeConfirmed 是否已确认类型 * @returns */ -export function handleTypeNode(node: arkts.AstNode) { - handleExpression(node) -} +export function handleTypeNode(node: arkts.AstNode) { } -export function handleTypedAstNode(node: arkts.AstNode) { -} +export function handleTypedAstNode(node: arkts.AstNode) { } /** * @@ -1689,38 +1599,29 @@ export function handleTypedAstNode(node: arkts.AstNode) { * @param isTypeConfirmed 是否已确认类型 * @returns */ -export function handleTypedStatement(node: arkts.AstNode) { - handleStatement(node) -} +export function handleTypedStatement(node: arkts.AstNode) { } export function handleTypeofExpression(node: arkts.AstNode) { if (!!node.argument) { handleAstNode(node.argument) } - handleExpression(node) } export function handleUnaryExpression(node: arkts.AstNode) { if (!!node.argument) { handleAstNode(node.argument) } - handleExpression(node) } -export function handleUndefinedLiteral(node: arkts.AstNode) { - handleLiteral(node) -} +export function handleUndefinedLiteral(node: arkts.AstNode) { } export function handleUpdateExpression(node: arkts.AstNode) { if (!!node.argument) { handleAstNode(node.argument) } - handleExpression(node) } -export function handleValidationInfo(node: arkts.AstNode) { - return -} +export function handleValidationInfo(node: arkts.AstNode) { } export function handleVariableDeclaration(node: arkts.AstNode) { if (!!node.annotations) { @@ -1729,7 +1630,6 @@ export function handleVariableDeclaration(node: arkts.AstNode) { if (!!node.declarators) { node.declarators.forEach((item: arkts.AstNode) => handleFunction(item, handleVariableDeclarator)) } - handleStatement(node) } export function handleVariableDeclarator(node: arkts.AstNode) { @@ -1739,7 +1639,6 @@ export function handleVariableDeclarator(node: arkts.AstNode) { if (!!node.name) { handleFunction(node.name, handleIdentifier) } - handleTypedStatement(node) } export function handleWhileStatement(node: arkts.AstNode) { @@ -1749,12 +1648,10 @@ export function handleWhileStatement(node: arkts.AstNode) { if (!!node.body) { handleAstNode(node.body) } - handleLoopStatement(node) } export function handleYieldExpression(node: arkts.AstNode) { if (!!node.argument) { handleAstNode(node.argument) } - handleExpression(node) } -- Gitee