From 6f80d9a2970dc816725a0b4e2686fabc9973d97a Mon Sep 17 00:00:00 2001 From: w30045791 Date: Fri, 4 Jul 2025 16:48:31 +0800 Subject: [PATCH] node and node_util Signed-off-by: w30045791 --- .../src/api_check_wrapper.ts | 171 ++ .../utils/ts_wrapper_node_util.ts | 1966 +++++++++++++++++ 2 files changed, 2137 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..09223f7eb1 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,171 @@ +/* + * 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, getjsDocByNodeFunctionMap } from '../utils/ts_wrapper_node_util' +import { ApiCheckWrapperServiceHost, JsDocNodeCheckConfig, FileCheckModuleInfo } from '../utils/api_check_wrapper_typedef' +import { ASTDeclaration, ASTIdentifier, ASTSourceFile, JSDoc, JSDocTag, JsDocNodeCheckConfigItem } from "../utils/api_check_wrapper_typedef"; +import { SINCE_TAG_NAME } from "../../utils/api_check_plugin_define"; +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); + 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; + console.log('[JSDOC_CHECK PLUGIN] AFTER CHECKED EXIT'); + // 获取根节点，开始遍历 + traverseProgram(script) + } + +} + +/** + * 处理import语句 + * @param node + */ +export function checkImport(node: arkts.AstNode) { + +} +/** + * 处理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): arkts.JsDocInfo[] { + let kind: number = arkts.arktsGlobal.generatedEs2panda._AstNodeTypeConst(arkts.arktsGlobal.context, decl.peer) + if (getjsDocByNodeFunctionMap.has(kind) && getjsDocByNodeFunctionMap.get(kind) !== undefined) { + return getjsDocByNodeFunctionMap.get(kind)!(decl) + } else { + console.log("debug cant found jsdoc node :" + decl.constructor.name) + return [] + } +} + + +function expressionCheckByJsDoc(declaration: ASTDeclaration, node: ASTIdentifier, sourceFile: string, checkConfig: JsDocNodeCheckConfigItem[]): void { + const jsDocs = getPeerTags(declaration); + const jsDocTags = getCurrentJSDoc(jsDocs); + + for (let i = 0; i < checkConfig.length; i++) { + const config = checkConfig[i]; + let tagNameExisted = false; + jsDocTags.forEach((item) => { + if (config.tagName.includes(item.name)) { + if (config.checkValidCallback) { + tagNameExisted = config.checkValidCallback(jsDocs, config); + } else { + tagNameExisted = true; + } + } + if (tagNameExisted && !config.tagNameShouldExisted) { + // TODO：打印报错拼接字段 + } + }); + if (config.tagNameShouldExisted && !tagNameExisted) { + // TODO：打印报错拼接字段 + } + } +} + +/** Get all JSDoc tags related to a node, including those on parent nodes. */ +function getPeerTags(declaration: ASTDeclaration): JSDoc[] { + let tags = []; + // TODO:具体逻辑待实现 + return tags!; +} + +/** 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.records && jsdoc.records.length > 0) { + for (let j = 0; j < jsdoc.records.length; j++) { + const tag: JSDocTag = jsdoc.records[j]; + if (tag.name === SINCE_TAG_NAME) { + const currentVersion: number = Number.parseInt(tag.comment); + if (!Number.isNaN(currentVersion) && currentVersion > maxVersion) { + maxVersion = currentVersion; + jsDocTags = jsdoc.records; + } + 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..03b66188cb 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,1966 @@ +/* + * 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 { checkIdntifier, checkImport } from "../src/api_check_wrapper" +export function traverseProgram(node: arkts.AstNode) { + if (isDumpTree) { + executeParse(node) + } + // 处理Identifier + if (!!node.statements) { + node.statements.forEach((item: arkts.AstNode) => handleAstNode(item)) + } +} + +type NodeTuple = [string, number]; +const items: NodeTuple[] = []; +const isDebug = false; +const isDumpTree = false; +class AstParser { + + /** + * 解析AST树并返回统计结果 + */ + public parse(root: arkts.AstNode): any { + const parseData = this.traverseNode(root); + } + + /** + * 后序遍历节点 + */ + private traverseNode(node: arkts.AstNode): any { + // 后序遍历：先处理子节点 + return this.traverseNodeProperties(node); + } + + /** + * 遍历节点的所有属性和getter方法 + */ + private traverseNodeProperties(node: arkts.Node): any { + const properties = this.getAllProperties(node); + const nodeData = {} + for (const propertyName of properties) { + try { + const value = (node as any)[propertyName]; + if (Array.isArray(value) && value.every(item => this.isAstNode(item))) { + nodeData[propertyName] = value.map(item => this.traverseNode(item)); + } + // 处理属性值：如果是节点，则递归遍历 + else if (this.isAstNode(value)) { + nodeData[propertyName] = this.traverseNode(value); + } else { + nodeData[propertyName] = value; + } + // 如果是节点数组，则遍历每个节点 + + } catch (error) { + console.warn(`访问属性 ${propertyName} 时出错:`, error); + } + } + return nodeData; + } + + /** + * 获取对象的所有属性名（包括getter方法） + */ + private getAllProperties(obj: object): string[] { + const properties = new Set(); + let currentPrototype = Object.getPrototypeOf(obj); + + while (currentPrototype !== null) { + if (currentPrototype.constructor.name == 'AstNode') { + break; + } + const descriptors = Object.getOwnPropertyDescriptors(currentPrototype); + + for (const [name, descriptor] of Object.entries(descriptors)) { + // 跳过构造函数 + if (name === 'constructor') continue; + + // 检查是否为getter或普通属性 + if (descriptor.get) { + properties.add(name); + } else if ('value' in descriptor && typeof descriptor.value !== 'function') { + properties.add(name); + } + } + + currentPrototype = Object.getPrototypeOf(currentPrototype); + } + + return Array.from(properties); + } + + /** + * 判断值是否为AST节点 + */ + private isAstNode(value: any): boolean { + return value !== null && value instanceof arkts.AstNode; + } +} + +function executeParse(root: arkts.AstNode) { + const parser = new AstParser(); + const result = parser.parse(root); + console.log("result: ", JSON.stringify(result)) +} + +export const getjsDocByNodeFunctionMap = new Map any>([ + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_DEFINITION, getClassDefinitionJSDocInformation], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ETS_MODULE, handleETSModule], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_INTERFACE_DECLARATION, getEtsModuleJSDocInformation], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_SCRIPT_FUNCTION, handleScriptFunction], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_FUNCTION_DECLARATION, handleFunctionDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_CLASS_PROPERTY, handleClassProperty], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_VARIABLE_DECLARATION, handleVariableDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_TS_TYPE_ALIAS_DECLARATION, handleTSTypeAliasDeclaration], + [arkts.Es2pandaAstNodeType.AST_NODE_TYPE_ARROW_FUNCTION_EXPRESSION, handleArrowFunctionExpression], +]) + +function getClassDefinitionJSDocInformation(node: arkts.AstNode): arkts.JsDocInfo[] { + return arkts.classDefinitionJSDocInformation(node); +} + +function getEtsModuleJSDocInformation(node: arkts.AstNode): arkts.JsDocInfo[] { + return arkts.etsModuleJSDocInformation(node); +} +function getTsInterfaceDeclarationJSDocInformation(node: arkts.AstNode): arkts.JsDocInfo[] { + return arkts.tsInterfaceDeclarationJSDocInformation(node); +} +function getScriptFunctionJSDocInformation(node: arkts.AstNode): arkts.JsDocInfo[] { + return arkts.scriptFunctionJSDocInformation(node); +} +function getFunctionDeclarationJSDocInformation(node: arkts.AstNode): arkts.JsDocInfo[] { + return arkts.functionDeclarationJSDocInformation(node); +} +function getClassPropertyJSDocInformation(node: arkts.AstNode): arkts.JsDocInfo[] { + return arkts.classPropertyJSDocInformation(node); +} +function getVariableDeclarationJSDocInformation(node: arkts.AstNode): arkts.JsDocInfo[] { + return arkts.variableDeclarationJSDocInformation(node); +} +function getTsTypeAliasDeclarationJSDocInformation(node: arkts.AstNode): arkts.JsDocInfo[] { + return arkts.tsTypeAliasDeclarationJSDocInformation(node); +} +function getArrowFunctionExpressionJSDocInformation(node: arkts.AstNode): arkts.JsDocInf[] { + return arkts.arrowFunctionExpressionJSDocInformation(node); +} + +export const nodeHandleFunctionMap = new Map void>([ + [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, isTypeConfirmed?: boolean) { + if (isDebug) { + console.log('[JSDOC_CHECK PLUGIN] ' + func.name); + items.push([func.name, node.peer.toString()]); + console.log("path: " + console.log(JSON.stringify(items))); + } + + func(node, isTypeConfirmed); + + if (isDebug) { + items.pop(); + } +} + +export function handleAstNode(node: arkts.AstNode) { + 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, isTypeConfirmed?: boolean) { + if (!isTypeConfirmed) { + handleAstNode(node) + return + } +} +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleAnnotatedExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!isTypeConfirmed) { + handleAstNode(node) + return + } + if (!!node.typeAnnotation) { + handleFunction(node.typeAnnotation, handleTypeNode) + } + handleExpression(node, true) +} + +export function handleAnnotatedStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleStatement(node, true) +} + +export function handleAnnotationDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.expr) { + handleFunction(node.expr, handleExpression) + } + 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, true) +} + +export function handleAnnotationUsage(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.expr) { + handleFunction(node.expr, handleExpression) + } + if (!!node.properties) { + node.properties.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + handleStatement(node, true) +} + +export function handleArrayExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.elements) { + node.elements.forEach((item: arkts.AstNode) => handleFunction(item, handleExpression)) + } + if (!!node.declarators) { + node.declarators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) + } + if (!!node.typeAnnotation) { + handleFunction(node.typeAnnotation, handleTypeNode) + } + handleAnnotatedExpression(node, true) +} + +export function handleArrowFunctionExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } + if (!!node.scriptFunction) { + handleFunction(node.scriptFunction, handleScriptFunction) + } + handleExpression(node, true) +} + +export function handleAssertStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.test) { + handleFunction(node.test, handleExpression) + } + if (!!node.second) { + handleFunction(node.second, handleExpression) + } + handleStatement(node, true) +} + +export function handleAssignmentExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.left) { + handleFunction(node.left, handleExpression) + } + if (!!node.right) { + handleFunction(node.right, handleExpression) + } + handleExpression(node, true) +} + +export function handleAstDumper(node: arkts.AstNode, isTypeConfirmed?: boolean) { + return +} + +export function handleAwaitExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.argument) { + handleFunction(node.argument, handleExpression) + } + handleExpression(node, true) +} + +export function handleBigIntLiteral(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleLiteral(node, true) +} + +export function handleBinaryExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.left) { + handleFunction(node.left, handleExpression) + } + if (!!node.right) { + handleFunction(node.right, handleExpression) + } + if (!!node.result) { + handleFunction(node.result, handleExpression) + } + handleExpression(node, true) +} + +export function handleBlockExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.statements) { + node.statements.forEach((item: arkts.AstNode) => handleFunction(item, handleStatement)) + } + handleExpression(node, true) +} + +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleBlockStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!isTypeConfirmed) { + handleAstNode(node) + return + } + if (!!node.statements) { + node.statements.forEach((item: arkts.AstNode) => handleFunction(item, handleStatement)) + } + handleStatement(node, true) +} + +export function handleBooleanLiteral(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleLiteral(node, true) +} + +export function handleBreakStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.ident) { + handleFunction(node.ident, handleIdentifier) + } + if (!!node.target) { + handleAstNode(node.target) + } + handleStatement(node, true) +} + +export function handleCallExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.trailingBlock) { + handleFunction(node.trailingBlock, handleBlockStatement) + } + if (!!node.expression) { + handleFunction(node.expression, handleExpression) + } + if (!!node.typeArguments) { + node.typeArguments.forEach((item: arkts.TypeNode) => handleFunction(item, handleTypeNode)) + } + if (!!node.arguments) { + node.arguments.forEach((item: arkts.Expression) => handleFunction(item, handleExpression)) + } + if (!!node.params) { + node.params.forEach((item: arkts.TypeNode) => handleFunction(item, handleTypeNode)) + } + handleExpression(node, true) +} + +export function handleCatchClause(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.param) { + handleFunction(node.param, handleExpression) + } + if (!!node.body) { + handleFunction(node.body, handleBlockStatement) + } + handleTypedStatement(node, true) +} + +export function handleChainExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.getExpression) { + handleFunction(node.getExpression, handleExpression) + } + handleExpression(node, true) +} + +export function handleCharLiteral(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleLiteral(node, true) +} + +export function handleClassDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!isTypeConfirmed) { + handleAstNode(node) + return + } + if (!!node.definition) { + handleFunction(node.definition, handleClassDefinition) + } + if (!!node.decorators) { + node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) + } + handleStatement(node, true) +} + +export function handleClassDefinition(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.ident) { + handleFunction(node.ident, handleIdentifier) + } + if (!!node.super) { + handleFunction(node.super, handleExpression); + } + 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) { + handleFunction(node.getAnonClass, handleClassDeclaration) + } + handleTypedAstNode(node, true) +} + +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleClassElement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!isTypeConfirmed) { + handleAstNode(node) + return + } + if (!!node.key) { + handleFunction(node.key, handleExpression) + } + if (!!node.value) { + handleFunction(node.value, handleExpression) + } + if (!!node.decorators) { + node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) + } + handleTypedStatement(node, true) +} + +export function handleClassExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.definition) { + handleFunction(node.definition, handleClassDefinition) + } + handleExpression(node, true) +} + +export function handleClassProperty(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.typeAnnotation) { + handleFunction(node.typeAnnotation, handleTypeNode) + } + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } + handleClassElement(node, true) +} + +export function handleClassStaticBlock(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleClassElement(node, true) +} + +export function handleConditionalExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.test) { + handleFunction(node.test, handleExpression) + } + if (!!node.consequent) { + handleFunction(node.consequent, handleExpression) + } + if (!!node.alternate) { + handleFunction(node.alternate, handleExpression) + } + handleExpression(node, true) +} + +export function handleContext(node: arkts.AstNode, isTypeConfirmed?: boolean) { +} + +export function handleContinueStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.ident) { + handleFunction(node.ident, handleIdentifier) + } + if (!!node.target) { + handleAstNode(node.target) + } + handleStatement(node, true) +} + +export function handleDebuggerStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleStatement(node, true) +} + +export function handleDecorator(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.expr) { + handleFunction(node.expr, handleExpression) + } + handleStatement(node, true) +} + +export function handleDirectEvalExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleCallExpression(node, true) +} + +export function handleDoWhileStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.test) { + handleFunction(node.test, handleExpression) + } + if (!!node.body) { + handleFunction(node.body, handleStatement) + } + handleLoopStatement(node, true) +} + +export function handleETSClassLiteral(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.expr) { + handleFunction(node.expr, handleTypeNode) + } + handleExpression(node, true) +} + +export function handleETSDynamicFunctionType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleETSFunctionType(node, true) +} + +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleETSFunctionType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!isTypeConfirmed) { + handleAstNode(node) + return + } + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterDeclaration) + } + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleFunction(item, handleExpression)) + } + if (!!node.returnType) { + handleFunction(node.returnType, handleTypeNode) + } + if (!!node.functionInterface) { + handleFunction(node.functionInterface, handleTSInterfaceDeclaration) + } + handleTypeNode(node, true) +} + +export function handleETSImportDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + // Bug注释 + // if(!!node.resolvedSource) { + // handleFunction(node.resolvedSource, handleStringLiteral) + // } + handleImportDeclaration(node, true) +} + +export function handleETSModule(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.ident) { + handleFunction(node.ident, handleIdentifier) + } + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } + handleBlockStatement(node, true) +} + +export function handleETSNewArrayInstanceExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.typeReference) { + handleFunction(node.typeReference, handleTypeNode) + } + if (!!node.dimension) { + handleFunction(node.dimension, handleExpression) + } + handleExpression(node, true) +} + +export function handleETSNewClassInstanceExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.getTypeRef) { + handleFunction(node.getTypeRef, handleExpression) + } + if (!!node.getArgments) { + node.getArgments.forEach((item: arkts.AstNode) => handleFunction(item, handleExpression)) + } + handleExpression(node, true) +} + +export function handleETSNewMultiDimArrayInstanceExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.dimensions) { + node.dimensions.forEach((item: arkts.AstNode) => handleFunction(item, handleExpression)) + } + if (!!node.typeReference) { + handleFunction(node.typeReference, handleTypeNode) + } + handleExpression(node, true) +} + +export function handleETSNullType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleTypeNode(node, true) +} + +export function handleETSPackageDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleStatement(node, true) +} + +export function handleETSParameterExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } + if (!!node.type) { + handleAstNode(node.type) + } + if (!!node.initializer) { + handleFunction(node.initializer, handleExpression) + } + if (!!node.identifier) { + handleFunction(node.identifier, handleIdentifier) + } + handleExpression(node, true) +} + +export function handleETSPrimitiveType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleTypeNode(node, true) +} + +export function handleETSReExportDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.getETSImportDeclarations) { + handleFunction(node.getETSImportDeclarations, handleETSImportDeclaration) + } + handleStatement(node, true) +} + +export function handleETSStructDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleClassDeclaration(node, true) +} + +export function handleETSTuple(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.getTupleTypeAnnotationsList) { + node.getTupleTypeAnnotationsList.forEach((item: arkts.AstNde) => handleFunction(item, handleTypeNode)) + } + handleTypeNode(node, true) +} + +export function handleETSTypeReference(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.part) { + handleFunction(node.part, handleETSTypeReferencePart) + } + handleTypeNode(node, true) +} + +export function handleETSTypeReferencePart(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.previous) { + handleFunction(node.previous, handleETSTypeReferencePart) + } + if (!!node.name) { + handleFunction(node.name, handleExpression) + } + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterInstantiation) + } + handleTypeNode(node, true) +} + +export function handleETSUndefinedType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleTypeNode(node, true) +} + +export function handleETSUnionType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.types) { + node.types.forEach((item: arkts.AstNde) => handleFunction(item, handleTypeNode)) + } + handleTypeNode(node, true) +} + +export function handleETSWildcardType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.typeReference) { + handleFunction(node.typeReference, handleETSTypeReference) + } + handleTypeNode(node, true) +} + +export function handleEmptyStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleStatement(node, true) +} + +export function handleExportAllDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.source) { + handleFunction(node.source, handleStringLiteral) + } + if (!!node.exported) { + handleFunction(node.exported, handleIdentifier) + } + handleStatement(node, true) +} + +export function handleExportDefaultDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.decl) { + handleAstNode(node.decl) + } + handleStatement(node, true) +} + +export function handleExportNamedDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + 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, true) +} + +export function handleExportSpecifier(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.local) { + handleFunction(node.local, handleIdentifier) + } + if (!!node.exported) { + handleFunction(node.exported, handleIdentifier) + } + handleStatement(node, true) +} + +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + */ +export function handleExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!isTypeConfirmed) { + handleAstNode(node) + return + } +} + +export function handleExpressionStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.expression) { + handleFunction(node.expression, handleExpression) + } + handleStatement(node, true) +} + +export function handleForInStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.left) { + handleAstNode(node.left) + } + if (!!node.right) { + handleFunction(node.right, handleExpression) + } + if (!!node.body) { + handleFunction(node.body, handleStatement) + } + handleLoopStatement(node, true) +} + +export function handleForOfStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.left) { + handleAstNode(node.left) + } + if (!!node.right) { + handleFunction(node.right, handleExpression) + } + if (!!node.body) { + handleFunction(node.body, handleStatement) + } + handleLoopStatement(node, true) +} + +export function handleForUpdateStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.init) { + handleAstNode(node.init) + } + if (!!node.test) { + handleFunction(node.test, handleExpression) + } + if (!!node.update) { + handleFunction(node.update, handleExpression) + } + if (!!node.body) { + handleFunction(node.body, handleStatement) + } + handleLoopStatement(node, true) +} + +export function handleFunctionDecl(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleScriptFunction(node, true) +} + +export function handleFunctionDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } + if (!!node.scriptFunction) { + handleFunction(node.scriptFunction, handleScriptFunction) + } + if (!!node.parameters) { + node.parameters.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + if (!!node.name) { + handleFunction(node.name, handleIdentifier) + } + if (!!node.body) { + handleFunction(node.body, handleBlockStatement) + } + if (!!node.typeParamsDecl) { + handleFunction(node.typeParamsDecl, handleTSTypeParameterDeclaration) + } + if (!!node.returnType) { + handleAstNode(node.returnType) + } + handleStatement(node, true) +} + +export function handleFunctionExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.scriptFunction) { + handleFunction(node.scriptFunction, handleScriptFunction) + } + handleExpression(node, true) +} + +export function handleFunctionSignature(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleFunction(item, handleExpression)) + } + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterDeclaration) + } + if (!!node.returnType) { + handleFunction(node.returnType, handleTypeNode) + } +} + +export function handleIdentifier(node: arkts.AstNode, isTypeConfirmed?: boolean) { + checkIdntifier(node); + + if (!!node.decorators) { + node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) + } + if (!!node.typeAnnotation) { + handleFunction(node.typeAnnotation, handleTypeNode) + } + handleAnnotatedExpression(node, true) +} + +export function handleIfStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.test) { + handleAstNode(node.test) + } + if (!!node.consequent) { + handleAstNode(node.consequent) + } + if (!!node.alternate) { + handleAstNode(node.alternate) + } + handleStatement(node, true) +} +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleImportDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + checkImport(node); + if (!isTypeConfirmed) { + handleAstNode(node) + return + } + if (!!node.source) { + handleFunction(node.source, handleStringLiteral) + } + if (!!node.specifiers) { + node.specifiers.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + handleStatement(node, true) +} + +export function handleImportDefaultSpecifier(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.local) { + handleFunction(node.local, handleIdentifier) + } + handleStatement(node, true) +} + +export function handleImportExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.source) { + handleFunction(node.source, handleStringLiteral) + } + handleExpression(node, true) +} + +export function handleImportNamespaceSpecifier(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.local) { + handleFunction(node.local, handleIdentifier) + } + handleStatement(node, true) +} + +export function handleImportSource(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.source) { + handleFunction(node.source, handleStringLiteral) + } + if (!!node.resolvedSource) { + handleFunction(node.resolvedSource, handleStringLiteral) + } +} + +export function handleImportSpecifier(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.imported) { + handleFunction(node.imported, handleIdentifier) + } + if (!!node.local) { + handleFunction(node.local, handleIdentifier) + } + handleStatement(node, true) +} + +export function handleInterfaceDecl(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleTSInterfaceDeclaration(node, true) +} + +export function handleLabelPair(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.ident) { + handleFunction(node.ident, handleIdentifier) + } + if (!!node.body) { + handleFunction(node.body, handleStatement) + } +} + +export function handleLabelledStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleStatement(node, true) +} +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleLiteral(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!isTypeConfirmed) { + handleAstNode(node) + return + } + handleExpression(node, true) +} +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleLoopStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!isTypeConfirmed) { + handleAstNode(node) + return + } + handleStatement(node, true) +} + +export function handleMaybeOptionalExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleExpression(node, true) +} + +export function handleMemberExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.object) { + handleFunction(node.object, handleExpression) + } + if (!!node.property) { + handleFunction(node.property, handleExpression) + } + handleExpression(node, true) +} + +export function handleMetaProperty(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleExpression(node, true) +} + +export function handleMethodDefinition(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.overloads) { + node.overloads.forEach((item: arkts.AstNode) => handleFunction(item, handleMethodDefinition)) + } + if (!!node.scriptFunction) { + handleFunction(node.scriptFunction, handleScriptFunction) + } + if (!!node.name) { + handleFunction(node.name, handleIdentifier) + } + handleClassElement(node, true) +} + +export function handleNamedType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.name) { + handleFunction(node.name, handleIdentifier) + } + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterInstantiation) + } + handleTypeNode(node, true) +} + +export function handleNewExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.callee) { + handleFunction(node.callee, handleExpression) + } + if (!!node.arguments) { + node.arguments.forEach((item: arkts.AstNode) => handleFunction(item, handleExpression)) + } + handleExpression(node, true) +} + +export function handleNullLiteral(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleLiteral(node, true) +} + +export function handleNumberLiteral(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleLiteral(node, true) +} + +export function handleObjectExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.properties) { + node.properties.forEach((item: arkts.AstNode) => handleFunction(item, handleExpression)) + } + if (!!node.decorators) { + node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) + } + if (!!node.typeAnnotation) { + handleFunction(node.typeAnnotation, handleTypeNode) + } + handleAnnotatedExpression(node, true) +} + +export function handleOmittedExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleExpression(node, true) +} + +export function handleOpaqueTypeNode(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleTypeNode(node, true) +} + +export function handlePrefixAssertionExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.expr) { + handleFunction(node.expr, handleExpression) + } + if (!!node.type) { + handleFunction(node.type, handleTypeNode) + } + handleExpression(node, true) +} + +export function handleProperty(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.key) { + handleFunction(node.key, handleExpression) + } + if (!!node.value) { + handleFunction(node.value, handleExpression) + } + handleExpression(node, true) +} + +export function handleRegExpLiteral(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleLiteral(node, true) +} + +export function handleReturnStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.argument) { + handleFunction(node.argument, handleExpression) + } + handleStatement(node, true) +} + +export function handleScriptFunction(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!isTypeConfirmed) { + handleAstNode(node) + return + } + if (!!node.id) { + handleFunction(node.id, handleIdentifier) + } + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleFunction(item, handleExpression)) + } + 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) { + handleFunction(node.returnTypeAnnotation, handleTypeNode) + } + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNde) => handleFunction(item, handleAnnotationUsage)) + } +} + +export function handleSequenceExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.sequence) { + node.sequence.forEach((item: arkts.AstNode) => handleFunction(item, handleExpression)) + } + handleExpression(node, true) +} + +export function handleSpreadElement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.argument) { + handleFunction(node.argument, handleExpression) + } + if (!!node.decorators) { + node.decorators.forEach((item: arkts.AstNode) => handleFunction(item, handleDecorator)) + } + if (!!node.typeAnnotation) { + handleFunction(node.typeAnnotation, handleTypeNode) + } + handleAnnotatedExpression(node, true) +} + +export function handleSrcDumper(node: arkts.AstNode, isTypeConfirmed?: boolean) { + return +} +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + */ +export function handleStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!isTypeConfirmed) { + handleAstNode(node) + return + } +} + +export function handleStringLiteral(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleLiteral(node, true) +} + +export function handleSuperExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.id) { + handleFunction(node.id, handleIdentifier) + } + handleExpression(node, true) +} + +export function handleSwitchCaseStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.test) { + handleFunction(node.test, handleExpression) + } + if (!!node.consequent) { + node.consequent.forEach((item: arkts.AstNode) => handleFunction(item, handleStatement)) + } + handleStatement(node, true) +} + +export function handleSwitchStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.discriminant) { + handleFunction(node.discriminant, handleExpression) + } + if (!!node.cases) { + node.cases.forEach((item: arkts.AstNode) => handleFunction(item, handleSwitchCaseStatement)) + } + handleStatement(node, true) +} + +export function handleTSAnyKeyword(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleTypeNode(node, true) +} + +export function handleTSArrayType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.elementType) { + handleFunction(node.elementType, handleTypeNode) + } +} + +export function handleTSAsExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.expr) { + handleFunction(node.expr, handleExpression) + } + if (!!node.typeAnnotation) { + handleFunction(node.typeAnnotation, handleTypeNode) + } + handleAnnotatedExpression(node, true) +} + +export function handleTSBigintKeyword(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleTypeNode(node, true) +} + +export function handleTSBooleanKeyword(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleTypeNode(node, true) +} + +export function handleTSClassImplements(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.expr) { + handleFunction(node.expr, handleExpression) + } + if (!!node.typeParameters) { + handleFunction(node.typeParameters, handleTSTypeParameterInstantiation) + } + handleExpression(node, true) +} + +export function handleTSConditionalType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.checkType) { + handleFunction(node.checkType, handleExpression) + } + if (!!node.extendsType) { + handleFunction(node.extendsType, handleExpression) + } + if (!!node.trueType) { + handleFunction(node.trueType, handleExpression) + } + if (!!node.falseType) { + handleFunction(node.falseType, handleExpression) + } + handleTypeNode(node, true) +} + +export function handleTSConstructorType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.typeParams) { + handleFunction(node.typeParameters, handleTSTypeParameterInstantiation) + } + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleFunction(item, handleExpression)) + } + if (!!node.returnType) { + handleFunction(node.returnType, handleTypeNode) + } + handleTypeNode(node, true) +} + +export function handleTSEnumDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + 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, true) +} + +export function handleTSEnumMember(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.key) { + handleFunction(node.key, handleExpression) + } + if (!!node.init) { + handleFunction(node.init, handleExpression) + } + handleStatement(node, true) +} + +export function handleTSExternalModuleReference(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.expr) { + handleFunction(node.expr, handleExpression) + } + handleExpression(node, true) +} + +export function handleTSFunctionType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterInstantiation) + } + if (!!node.params) { + node.params.forEach((item: arkts.TypeNode) => handleFunction(item, handleExpression)) + } + if (!!node.returnType) { + handleFunction(node.returnType, handleTypeNode) + } + handleTypeNode(node, true) +} + +export function handleTSImportEqualsDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.id) { + handleFunction(node.id, handleIdentifier) + } + if (!!node.moduleReference) { + handleFunction(node.moduleReference, handleExpression) + } + handleStatement(node, true) +} + +export function handleTSImportType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterInstantiation) + } + if (!!node.params) { + handleFunction(node.params, handleExpression) + } + if (!!node.qualifier) { + handleFunction(node.qualifier, handleExpression) + } + handleTypeNode(node, true) +} + +export function handleTSIndexSignature(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.objectType) { + handleFunction(node.objectType, handleTypeNode) + } + if (!!node.indexType) { + handleFunction(node.indexType, handleTypeNode) + } + handleTypeNode(node, true) +} + +export function handleTSIndexedAccessType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.param) { + handleFunction(node.param, handleExpression) + } + if (!!node.typeAnnotation) { + handleFunction(node.typeAnnotation, handleTypeNode) + } + handleTypedAstNode(node, true) +} + +export function handleTSInferType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.typeParam) { + handleFunction(node.typeParam, handleTSTypeParameter) + } + handleTypeNode(node, true) +} + +export function handleTSInterfaceBody(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.body) { + node.body.forEach((item: arkts.TypeNode) => handleAstNode(item)) + } + handleExpression(node, true) +} + +export function handleTSInterfaceDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!isTypeConfirmed) { + handleAstNode(node) + return + } + 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) { + handleFunction(node.getAnonClass, handleClassDeclaration) + } + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } + handleTypedStatement(node, true) +} + +export function handleTSInterfaceHeritage(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.expr) { + handleFunction(node.expr, handleTypeNode) + } + handleExpression(node, true) +} + +export function handleTSIntersectionType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.types) { + node.types.forEach((item: arkts.AstNode) => handleFunction(item, handleExpression)) + } + handleTypeNode(node, true) +} + +export function handleTSLiteralType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.literal) { + handleFunction(node.literal, handleExpression) + } + handleTypeNode(node, true) +} + +export function handleTSMappedType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.typeParameter) { + handleFunction(node.typeParameter, handleTSTypeParameter) + } + if (!!node.typeAnnotation) { + handleFunction(node.typeAnnotation, handleTypeNode) + } + handleTypeNode(node, true) +} + +export function handleTSMethodSignature(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.key) { + handleFunction(node.key, handleExpression) + } + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterDeclaration) + } + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleFunction(item, handleExpression)) + } + if (!!node.returnTypeAnnotation) { + handleFunction(node.returnTypeAnnotation, handleTypeNode) + } +} + +export function handleTSModuleBlock(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.statements) { + node.statements.forEach((item: arkts.AstNode) => handleFunction(item, handleStatement)) + } + handleStatement(node, true) +} + +export function handleTSModuleDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.name) { + handleFunction(node.name, handleExpression) + } + if (!!node.body) { + handleFunction(node.body, handleStatement) + } + handleStatement(node, true) +} + +export function handleTSNamedTupleMember(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.label) { + handleFunction(node.label, handleExpression) + } + if (!!node.elementType) { + handleFunction(node.elementType, handleTypeNode) + } + handleTypeNode(node, true) +} + +export function handleTSNeverKeyword(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleTypeNode(node, true) +} + +export function handleTSNonNullExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.expr) { + handleFunction(node.expr, handleExpression) + } + handleExpression(node, true) +} + +export function handleTSNullKeyword(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleTypeNode(node, true) +} + +export function handleTSNumberKeyword(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleTypeNode(node, true) +} + +export function handleTSObjectKeyword(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleTypeNode(node, true) +} + +export function handleTSParameterProperty(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.parameter) { + handleFunction(node.parameter, handleExpression) + } + handleExpression(node, true) +} + +export function handleTSParenthesizedType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.type) { + handleFunction(node.type, handleExpression) + } + handleTypeNode(node, true) +} + +export function handleTSPropertySignature(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.key) { + handleFunction(node.key, handleExpression) + } + if (!!node.typeAnnotation) { + handleFunction(node.typeAnnotation, handleTypeNode) + } + handleAnnotatedAstNode(node, true) +} + +export function handleTSQualifiedName(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.left) { + handleFunction(node.left, handleExpression) + } + if (!!node.right) { + handleFunction(node.right, handleIdentifier) + } + handleExpression(node, true) +} + +export function handleTSSignatureDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterDeclaration) + } + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleFunction(item, handleExpression)) + } + if (!!node.returnTypeAnnotation) { + handleFunction(node.returnTypeAnnotation, handleTypeNode) + } + handleTypedAstNode(node, true) +} + +export function handleTSStringKeyword(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleTypeNode(node, true) +} + +export function handleTSThisType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleTypeNode(node, true) +} + +export function handleTSTupleType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.elementType) { + node.elementType.forEach((item: arkts.AstNode) => handleFunction(item, handleTypeNode)) + } + handleTypeNode(node, true) +} + +export function handleTSTypeAliasDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + 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) { + handleFunction(node.typeAnnotation, handleTypeNode) + } + handleAnnotatedStatement(node, true) +} + +export function handleTSTypeAssertion(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.getExpression) { + handleFunction(node.getExpression, handleExpression) + } + if (!!node.typeAnnotation) { + handleFunction(node.typeAnnotation, handleTypeNode) + } + handleAnnotatedExpression(node, true) +} + +export function handleTSTypeLiteral(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.members) { + node.members.forEach((item: arkts.AstNode) => handleAstNode(item)) + } + if (!!node.type) { + handleFunction(node.type, handleTypeNode) + } + handleTypeNode(node, true) +} + +export function handleTSTypeOperator(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.type) { + handleFunction(node.type, handleTypeNode) + } + handleTypeNode(node, true) +} + +export function handleTSTypeParameter(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.name) { + handleFunction(node.name, handleIdentifier) + } + if (!!node.constraint) { + handleFunction(node.constraint, handleTypeNode) + } + if (!!node.defaultType) { + handleFunction(node.defaultType, handleTypeNode) + } + if (!!node.annotations) { + node.annotations.forEach((item: arkts.AstNode) => handleFunction(item, handleAnnotationUsage)) + } + handleExpression(node, true) +} + +export function handleTSTypeParameterDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleFunction(item, handleTSTypeParameter)) + } + handleExpression(node, true) +} + +export function handleTSTypeParameterInstantiation(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.params) { + node.params.forEach((item: arkts.AstNode) => handleFunction(item, handleTypeNode)) + } + handleExpression(node, true) +} + +export function handleTSTypePredicate(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.parameterName) { + handleFunction(node.parameterName, handleExpression) + } + if (!!node.typeAnnotation) { + handleFunction(node.typeAnnotation, handleTypeNode) + } + handleTypeNode(node, true) +} + +export function handleTSTypeQuery(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.exprName) { + handleFunction(node.exprName, handleExpression) + } + handleTypeNode(node, true) +} + +export function handleTSTypeReference(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.typeName) { + handleFunction(node.typeName, handleExpression) + } + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterInstantiation) + } + handleTypeNode(node, true) +} + +export function handleTSUndefinedKeyword(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleTypeNode(node, true) +} + +export function handleTSUnionType(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.types) { + node.types.forEach((item: arkts.AstNode) => traverseProgram(item)) + } + handleTypeNode(node, true) +} + +export function handleTSUnknownKeyword(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleTypeNode(node, true) +} + +export function handleTSVoidKeyword(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleTypeNode(node, true) +} + +export function handleTaggedTemplateExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.tag) { + handleFunction(node.tag, handleExpression) + } + if (!!node.quasi) { + handleFunction(node.quasi, handleTemplateLiteral) + } + if (!!node.typeParams) { + handleFunction(node.typeParams, handleTSTypeParameterInstantiation) + } + handleExpression(node, true) +} + +export function handleTemplateElement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleExpression(node, true) +} + +export function handleTemplateLiteral(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.quasis) { + node.quasis.forEach((item: arkts.AstNode) => handleFunction(item, handleTemplateLiteral)) + } + if (!!node.expressions) { + node.expressions.forEach((item: arkts.AstNode) => handleFunction(item, handleExpression)) + } + handleExpression(node, true) +} + +export function handleThisExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleExpression(node, true) +} + +export function handleThrowStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.argument) { + handleFunction(node.argument, handleExpression) + } + handleStatement(node, true) +} + +export function handleTryStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.finallyBlock) { + handleFunction(node.finallyBlock, handleBlockStatement) + } + if (!!node.block) { + handleFunction(node.block, handleBlockStatement) + } + if (!!node.catchClauses) { + node.catchClauses.forEach((item: arkts.AstNode) => handleFunction(item, handleCatchClause)) + } + handleStatement(node, true) +} + +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleTypeNode(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!isTypeConfirmed) { + handleAstNode(node) + return + } + handleExpression(node, true) +} + +export function handleTypedAstNode(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!isTypeConfirmed) { + handleAstNode(node) + return + } +} + +/** + * + * @param node 当前节点 + * @param isTypeConfirmed 是否已确认类型 + * @returns + */ +export function handleTypedStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!isTypeConfirmed) { + handleAstNode(node) + return + } + handleStatement(node, true) +} + +export function handleTypeofExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.argument) { + handleFunction(node.argument, handleExpression) + } + handleExpression(node, true) +} + +export function handleUnaryExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.argument) { + handleFunction(node.argument, handleExpression) + } + handleExpression(node, true) +} + +export function handleUndefinedLiteral(node: arkts.AstNode, isTypeConfirmed?: boolean) { + handleLiteral(node, true) +} + +export function handleUpdateExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.argument) { + handleFunction(node.argument, handleExpression) + } + handleExpression(node, true) +} + +export function handleValidationInfo(node: arkts.AstNode, isTypeConfirmed?: boolean) { + return +} + +export function handleVariableDeclaration(node: arkts.AstNode, isTypeConfirmed?: boolean) { + 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, true) +} + +export function handleVariableDeclarator(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.initializer) { + handleAstNode(node.initializer) + } + if (!!node.name) { + handleFunction(node.name, handleIdentifier) + } + handleTypedStatement(node, true) +} + +export function handleWhileStatement(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.test) { + handleFunction(node.test, handleExpression) + } + if (!!node.body) { + handleFunction(node.body, handleStatement) + } + handleLoopStatement(node, true) +} + +export function handleYieldExpression(node: arkts.AstNode, isTypeConfirmed?: boolean) { + if (!!node.argument) { + handleFunction(node.argument, handleExpression) + } + handleExpression(node, true) +} -- Gitee