@lcap/nasl 4.1.0-creator.1 → 4.1.0-creator.3

package/out/natural/transforms/transform2LogicItem.js

@@ -24,7 +24,7 @@ class TransformManager {
     apply(node, options) {
         if (node.type === 'CallExpression') {
             if (node.callee.type === 'CallExpression')
-                (0, utils_1.throwError)('不支持连续调用！', node.callee);
+                return (0, utils_1.throwError)(options?.parsingId, '不支持连续调用！', node.callee);
             const callee = flatMemberExpression(node.callee);
             if (callee[0]
                 && callee[0].type === 'CallExpression'
@@ -37,7 +37,7 @@ class TransformManager {
             else {
                 for (const calleeItem of callee) {
                     if (calleeItem.type !== 'Identifier' && !(calleeItem.type === 'FunctionExpression' && calleeItem.id?.name === 'match')) {
-                        (0, utils_1.throwError)('不支持连续调用！', node.callee);
+                        return (0, utils_1.throwError)(options?.parsingId, '不支持连续调用！', node.callee);
                     }
                 }
             }
@@ -47,7 +47,7 @@ class TransformManager {
                     return transform(node, calleeName, callee, options);
                 }
             }
-            (0, utils_1.throwError)(`Unhandled node ${callee.map((item) => item.name).join('.')}`, node.type, node);
+            return (0, utils_1.throwError)(options?.parsingId, `不支持的节点类型 ${callee.map((item) => item.name).join('.')}`, node.type, node);
         }
         else {
             for (const [type, transform] of this.transforms) {
@@ -55,7 +55,7 @@ class TransformManager {
                     return transform(node, options);
                 }
             }
-            (0, utils_1.throwError)('Unhandled node', node.type, node);
+            return (0, utils_1.throwError)(options?.parsingId, '不支持的节点类型', node.type, node);
         }
     }
 }
@@ -77,7 +77,7 @@ function transformTSCode2SubLogic(node, options) {
         statements = [...node?.body?.directives, ...node?.body?.body];
     }
     parameters.forEach((node) => {
-        const param = transform2Param(node);
+        const param = transform2Param(node, options);
         param && logic.addParam(param);
     });
     const newStatements = [];
@@ -121,9 +121,9 @@ function transformTSCode2SubLogic(node, options) {
     }
     return logic;
 }
-function assertAssignmentRightIsNotAnonymousFunction(expression) {
+function assertAssignmentRightIsNotAnonymousFunction(expression, options) {
     if (expression?.concept === 'AnonymousFunction')
-        (0, utils_1.throwError)('Anonymous function is not allowed in assignment', expression.toNaturalTS());
+        return (0, utils_1.throwError)(options?.parsingId, 'Anonymous function is not allowed in assignment');
     return expression;
 }
 function fixExpression(arg, options, supportSubLogic = false) {
@@ -269,7 +269,7 @@ function fixLogicNode(node) {
     }
 }
 exports.fixLogicNode = fixLogicNode;
-function transform2Param(node) {
+function transform2Param(node, options) {
     const exclude = ['event'];
     if (node.type === 'ObjectProperty') {
         const typeAnnotation = node?.value?.name ? utils_1.naslTypes.TypeAnnotation.createPrimitive((node?.value).name) : null;
@@ -281,7 +281,7 @@ function transform2Param(node) {
             name,
             typeAnnotation,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr', isRestricted: true }),
+                expression: transform2LogicItem(defaultValueExpression, { parsingId: options?.parsingId, transformType: 'attr', isRestricted: true }),
             }),
         });
     }
@@ -293,9 +293,9 @@ function transform2Param(node) {
         let defaultValueExpression = node.optional ? { type: 'NullLiteral' } : undefined;
         return new utils_1.naslTypes.Param({
             name,
-            typeAnnotation: typeAnnotation ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation) : null,
+            typeAnnotation: typeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation, options) || undefined,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr', isRestricted: true }),
+                expression: transform2LogicItem(defaultValueExpression, { parsingId: options?.parsingId, transformType: 'attr', isRestricted: true }),
             }),
         });
     }
@@ -308,9 +308,9 @@ function transform2Param(node) {
         return new utils_1.naslTypes.Param({
             name,
             required: !node.optional,
-            typeAnnotation: typeAnnotation ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation) : null,
+            typeAnnotation: typeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation, options) || undefined,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr', isRestricted: true }),
+                expression: transform2LogicItem(defaultValueExpression, { parsingId: options?.parsingId, transformType: 'attr', isRestricted: true }),
             }),
         });
     }
@@ -331,14 +331,14 @@ function transform2Param(node) {
             return null;
         return new utils_1.naslTypes.Param({
             name,
-            typeAnnotation: typeAnnotation ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation) : null,
+            typeAnnotation: typeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(typeAnnotation, options) || undefined,
             defaultValue: defaultValueExpression && new utils_1.naslTypes.DefaultValue({
-                expression: transform2LogicItem(defaultValueExpression, { transformType: 'attr', isRestricted: true }),
+                expression: transform2LogicItem(defaultValueExpression, { parsingId: options?.parsingId, transformType: 'attr', isRestricted: true }),
             }),
         });
     }
     else {
-        (0, utils_1.throwError)('Unhandled node', node);
+        return (0, utils_1.throwError)(options?.parsingId, '在输入参数中不支持节点类型', node);
     }
 }
 exports.transform2Param = transform2Param;
@@ -442,7 +442,7 @@ function transform2BinaryExpression(node, options) {
             right: transformNodeFunction(node.right, options),
         });
     }
-    (0, utils_1.throwError)('Unhandled node', node.type, node);
+    return (0, utils_1.throwError)(options?.parsingId, '在二元表达式中不支持节点类型', node.type, node);
 }
 exports.transform2BinaryExpression = transform2BinaryExpression;
 function transformDefaultExpression(node, options) {
@@ -455,7 +455,7 @@ function transformConditionalExpression(node, options) {
         const expr = (0, utils_1.generate)(node.test)?.code;
         const then_expr = (0, utils_1.generate)(node.consequent)?.code;
         const else_expr = (0, utils_1.generate)(node.alternate)?.code;
-        (0, utils_1.throwError)(`数据查询中不支持条件表达式！${(0, utils_1.generate)(node)?.code}, 请使用 SQL函数 IF(${expr} == null, ${then_expr}, ${else_expr})`);
+        return (0, utils_1.throwError)(options?.parsingId, `数据查询中不支持条件表达式！${(0, utils_1.generate)(node)?.code}, 请使用 SQL函数 IF(${expr} == null, ${then_expr}, ${else_expr})`);
     }
     const test = transformNodeFunction(node.test, options);
     const consequent = transformNodeFunction(node.consequent, options);
@@ -479,12 +479,12 @@ function transformConditionalExpression(node, options) {
         cases: [
             new utils_1.naslTypes.MatchCase({
                 patterns: [new utils_1.naslTypes.BooleanLiteral({ value: 'true' })],
-                body: [consequent],
+                body: consequent ? [consequent] : [],
                 isMatchedTypeEnumable: true,
             }),
             new utils_1.naslTypes.MatchCase({
                 patterns: [],
-                body: [alternate],
+                body: alternate ? [alternate] : [],
             }),
         ],
     });
@@ -495,7 +495,7 @@ function transformArrayExpression(node, options) {
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
     return new utils_1.naslTypes.NewList({
         typeAnnotation,
-        items: node?.elements?.map((arg) => transformNodeFunction(arg, { ...options, typeAnnotation: undefined })),
+        items: node?.elements?.map((arg) => transformNodeFunction(arg, { ...options, typeAnnotation: undefined })).filter(Boolean),
     });
 }
 function transform2NewAnonymousStructure(node, options) {
@@ -508,11 +508,11 @@ function transform2NewAnonymousStructure(node, options) {
                 item.naslType = currentType.typeAnnotation;
             }
             else {
-                (0, utils_1.throwError)('Do not allow NullLiteral without type, you can use as to carry the type', node);
+                return (0, utils_1.throwError)(options?.parsingId, '匿名数据结构的属性中, 不允许出现没有类型的 null 值，请使用 as 关键字来指定类型，如 { price: null as Decimal }', node);
             }
         }
         else if (itemValue.type === 'TSAsExpression') {
-            const typeAnnotation = (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(itemValue.typeAnnotation);
+            const typeAnnotation = (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(itemValue.typeAnnotation, options);
             item.naslType = typeAnnotation;
         }
     }
@@ -545,15 +545,15 @@ function transform2NewExpression(calleeName, node, options) {
         }
         else {
             typeAnnotation = utils_1.naslTypes.TypeAnnotation.createGeneric('List', {
-                typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation),
+                typeArguments: node?.typeParameters?.params.map((type) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(type, options)).filter(Boolean),
             });
         }
         if (node?.arguments && node?.arguments?.[0]?.type !== 'ArrayExpression') {
-            (0, utils_1.throwError)('Not allowed code in NewList', node);
+            return (0, utils_1.throwError)(options?.parsingId, 'NewList 中不允许出现非数组表达式', node);
         }
         return new utils_1.naslTypes.NewList({
             typeAnnotation: node?.typeParameters ? typeAnnotation : undefined,
-            items: node?.arguments?.[0]?.elements?.map((arg) => transformNodeFunction(arg, options)),
+            items: node?.arguments?.[0]?.elements?.map((arg) => transformNodeFunction(arg, options)).filter(Boolean),
         });
     }
     if (calleeName === 'NewMap') {
@@ -569,7 +569,7 @@ function transform2NewExpression(calleeName, node, options) {
         }
         else {
             typeAnnotation = utils_1.naslTypes.TypeAnnotation.createGeneric('Map', {
-                typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation),
+                typeArguments: node?.typeParameters?.params.map((type) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(type, options)).filter(Boolean),
             });
         }
         return new utils_1.naslTypes.NewMap({
@@ -582,13 +582,13 @@ function transform2NewExpression(calleeName, node, options) {
         const typeParam = node.typeParameters?.params[0];
         const typeNamespaceAndName = typeParam ? (0, utils_1.generate)(typeParam).code : '';
         if (!typeNamespaceAndName)
-            (0, utils_1.throwError)('Not allowed empty namespace in NewEntity', node);
+            return (0, utils_1.throwError)(options?.parsingId, 'NewEntity 中必须指定类型', node);
         return transform2NewStructure(typeNamespaceAndName, node.arguments[0], options);
     }
     if (calleeName === 'NewAnonymousStructure') {
         return transform2NewAnonymousStructure(node.arguments[0], options);
     }
-    (0, utils_1.throwError)('Unhandled ArrowFunctionExpression node', node.type, node);
+    return (0, utils_1.throwError)(options?.parsingId, '在新建表达式中不支持节点类型', node.type, node);
 }
 function pushElseIf(ifNode, switchStatement, options) {
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
@@ -653,7 +653,7 @@ function transform2ArrayPattern(decl, options) {
             if (options.transformType === 'logic') {
                 options.logic.variables.push(new utils_1.naslTypes.Variable({
                     name: element.name,
-                    typeAnnotation: varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation),
+                    typeAnnotation: varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation, options) || undefined,
                 }));
             }
         }
@@ -696,7 +696,7 @@ function transform2VariableAndAddAssignment(node, options) {
         let typeAnnotation;
         if (options.transformType === 'logic' && ![...options.logic.variables, ...options.logic.returns].some((variable) => variable.name === variableName)) {
             const varTypeAnnotation = decl.id.typeAnnotation?.typeAnnotation;
-            typeAnnotation = varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation);
+            typeAnnotation = varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation, options) || undefined;
             options.logic.variables.push(new utils_1.naslTypes.Variable({
                 name: variableName,
                 typeAnnotation,
@@ -705,14 +705,14 @@ function transform2VariableAndAddAssignment(node, options) {
         if (decl.init) {
             const calleeName = (0, utils_1.generate)(decl?.init?.callee).code;
             const varTypeAnnotation = decl?.id?.typeAnnotation?.typeAnnotation;
-            typeAnnotation = varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation);
+            typeAnnotation = varTypeAnnotation && (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(varTypeAnnotation, options) || undefined;
             if (calleeName === 'nasl.oql.query' && varTypeAnnotation) {
                 decl.init.typeAnnotations = varTypeAnnotation;
             }
             options.typeAnnotation = typeAnnotation;
             newNode = new utils_1.naslTypes.Assignment({
                 left: transformNodeFunction(decl.id, options),
-                right: assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(decl.init, { ...options, typeAnnotation })),
+                right: assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(decl.init, { ...options, typeAnnotation }), options) || undefined,
             });
         }
     });
@@ -860,7 +860,7 @@ function transform2SelectQueryFieldExpression(node, options) {
         // @TODO
     }
     else {
-        (0, utils_1.throwError)('Unsupported expression type for QueryFieldExpression', expression.type, expression);
+        return (0, utils_1.throwError)(options?.parsingId, '在 QueryFieldExpression 不支持表达式类型', expression.type, expression);
     }
 }
 function transform2QueryAggregateExpression(node, options) {
@@ -869,10 +869,10 @@ function transform2QueryAggregateExpression(node, options) {
     const arg = callExpression.arguments[0];
     if (arg.type !== 'MemberExpression') {
         const code = (0, utils_1.generate)(arg).code;
-        (0, utils_1.throwError)(`聚合函数的输入只能是表字段(实体.属性)，但AVG(${code})中的${code}不是表字段`);
+        return (0, utils_1.throwError)(options?.parsingId, `聚合函数的输入只能是表字段(实体.属性)，但AVG(${code})中的${code}不是表字段`);
     }
     if (callExpression.arguments?.length > 1) {
-        (0, utils_1.throwError)(`聚合函数${callExpression.callee.name}只支持一个参数`);
+        return (0, utils_1.throwError)(options?.parsingId, `聚合函数${callExpression.callee.name}只支持一个参数`);
     }
     return new utils_1.naslTypes.QueryAggregateExpression({
         asName: asNameNode.name,
@@ -882,10 +882,10 @@ function transform2QueryAggregateExpression(node, options) {
 }
 function transform2AnonymousFunction(node, options) {
     if (node.body.type === 'BlockStatement')
-        (0, utils_1.throwError)('Anonymous function with block statement is not supported', node);
+        return (0, utils_1.throwError)(options?.parsingId, 'Anonymous function with block statement is not supported', node);
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
     return new utils_1.naslTypes.AnonymousFunction({
-        params: node.params.map((param) => transform2Param(param)),
+        params: node.params.map((param) => transform2Param(param, options)).filter(Boolean),
         body: transformNodeFunction(node.body, options),
     });
 }
@@ -914,7 +914,7 @@ function transform2Assignment(node, options) {
     }
     return new utils_1.naslTypes.Assignment({
         left: transformNodeFunction(node.left, options),
-        right: assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(node.right, options)),
+        right: assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(node.right, options), options) || undefined,
     });
 }
 exports.transform2Assignment = transform2Assignment;
@@ -991,15 +991,15 @@ function transformReturnStatement2AssignmentOrEnd(node, options) {
         }
     }
     if (!logic.returns.length) {
-        const typeAnnotation = node?.argument?.type === 'TSAsExpression' ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node?.argument?.typeAnnotation) : undefined;
+        const typeAnnotation = node?.argument?.type === 'TSAsExpression' ? (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node?.argument?.typeAnnotation, options) || undefined : undefined;
         logic.returns.push(new utils_1.naslTypes.Return({
             name: 'result',
             typeAnnotation
         }));
     }
     const leftName = logic.returns[0].name;
-    const right = assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(argument, options));
-    if (right.concept === 'Identifier' && right.name === leftName) {
+    const right = assertAssignmentRightIsNotAnonymousFunction(transformNodeFunction(argument, options), options) || undefined;
+    if (right && right.concept === 'Identifier' && right.name === leftName) {
         return new utils_1.naslTypes.End();
     }
     else {
@@ -1142,7 +1142,7 @@ function transformNewExpression(node, options) {
     else if (calleeName.includes('.entities.') || calleeName.includes('.structures.')) {
         return transform2NewStructure(calleeName, node.arguments[0], options);
     }
-    (0, utils_1.throwError)('Unhandled node', node.type, node);
+    return (0, utils_1.throwError)(options?.parsingId, '在新建表达式中不支持节点类型', node.type, node);
 }
 exports.transformNewExpression = transformNewExpression;
 function transformMemberExpression(node, options) {
@@ -1185,7 +1185,7 @@ function transformMemberExpression(node, options) {
             const callCalleeName = (0, utils_1.generate)(callExpression)?.code;
             let callResult = transformCall2CallViewElementLogic(callExpression, callCalleeName, callCallee, options);
             const remainingCallee = callee.slice(1);
-            if (remainingCallee.length > 0) {
+            if (remainingCallee.length > 0 && callResult) {
                 return unflatMemberExpression(remainingCallee, options, callResult);
             }
             return callResult;
@@ -1272,7 +1272,7 @@ function transformCallFunctionExpression2Match(node, calleeName, callee, options
     const arg = node.arguments[0];
     const ifStatement = node.callee.body.body[0];
     if (ifStatement.type !== 'IfStatement') {
-        (0, utils_1.throwError)('Match 函数体内必须是一个 if 语句', ifStatement);
+        return (0, utils_1.throwError)(options?.parsingId, 'Match 函数体内必须是一个 if 语句', ifStatement);
     }
     const flatedIfStatements = flatIfStatementForMatch(ifStatement);
     const match = new utils_1.naslTypes.Match({
@@ -1285,7 +1285,7 @@ function transformCallFunctionExpression2Match(node, calleeName, callee, options
                     argument = _case.consequent.body[0].argument;
                 }
                 else {
-                    (0, utils_1.throwError)('Match Case 的 if 中只能写一个 return 语句', _case.consequent);
+                    return (0, utils_1.throwError)(options?.parsingId, 'Match Case 的 if 中只能写一个 return 语句', _case.consequent);
                 }
             }
             else {
@@ -1293,15 +1293,16 @@ function transformCallFunctionExpression2Match(node, calleeName, callee, options
                     argument = _case.consequent.argument;
                 }
                 else {
-                    (0, utils_1.throwError)('Match Case 的 if 中只能写一个 return 语句', _case.consequent);
+                    return (0, utils_1.throwError)(options?.parsingId, 'Match Case 的 if 中只能写一个 return 语句', _case.consequent);
                 }
             }
+            const bodyNode = transformNodeFunction(argument, options);
             return new utils_1.naslTypes.MatchCase({
                 isMatchedTypeEnumable: false,
                 patterns: !_case.test ? [] : flatMatchPatternsExpression(transformNodeFunction(_case.test, options)),
-                body: [transformNodeFunction(argument, options)],
+                body: bodyNode ? [bodyNode] : [],
             });
-        }),
+        }).filter(Boolean),
     });
     if (!match.cases.length || match.cases[match.cases.length - 1].patterns.length) {
         match.cases.push(new utils_1.naslTypes.MatchCase({
@@ -1338,7 +1339,7 @@ function transformCallFunctionExpression2Match(node, calleeName, callee, options
 exports.transformCallFunctionExpression2Match = transformCallFunctionExpression2Match;
 function transformCall2CallViewElementLogic(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用', node);
     if (calleeName?.includes('getPropValue') || calleeName?.includes('setPropValue')) {
         const componentName = callee?.[1]?.name;
         const propertyName = node?.arguments?.[0]?.value;
@@ -1374,7 +1375,7 @@ function transformCall2CallViewElementLogic(node, calleeName, callee, options) {
 exports.transformCall2CallViewElementLogic = transformCall2CallViewElementLogic;
 function transformCall2CallEntityLogic(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用', node);
     const entityName = callee[0].name.replace(/Entity$/, '');
     // console.log('callee', callee);
     return new utils_1.naslTypes.CallLogic({
@@ -1388,7 +1389,7 @@ function transformCall2CallEntityLogic(node, calleeName, callee, options) {
 exports.transformCall2CallEntityLogic = transformCall2CallEntityLogic;
 function transformCall2CallDataSourceLogic(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用', node);
     if (calleeName?.includes('.entities.')) {
         const calleeNamespace = (0, utils_1.generate)(node?.callee?.object?.object)?.code;
         const entityName = node?.callee?.object?.property?.name?.replace(/Entity$/, '');
@@ -1448,9 +1449,9 @@ function transformCall2CallDataSourceLogic(node, calleeName, callee, options) {
 exports.transformCall2CallDataSourceLogic = transformCall2CallDataSourceLogic;
 function transformCall2OQLQuery(node, calleeName, callee, options) {
     if (options?.isInFrontend)
-        (0, utils_1.throwError)('OQL组件不支持在前端使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, 'OQL组件不支持在前端使用', node);
     if (options?.isRestricted)
-        (0, utils_1.throwError)('OQL组件不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, 'OQL组件不支持在组件或默认值表达式中使用', node);
     if (options.transformType === 'logic' && options?.logicType === 'global_logic') {
         // const _typeAnnotation = node?.typeParameters?.params?.length > 0 ? naslTypes.TypeAnnotation.createGeneric('List', {
         //   typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType })),
@@ -1460,13 +1461,13 @@ function transformCall2OQLQuery(node, calleeName, callee, options) {
         return new utils_1.naslTypes.OqlQueryComponent({
             dataSource: 'app.dataSources.defaultDS',
             code,
-            typeAnnotation: (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node?.typeAnnotations)
+            typeAnnotation: (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node?.typeAnnotations, options) || undefined,
         });
     }
 }
 function transformCall2ConsoleLog(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: 'nasl.logging',
         calleeName: 'INFO',
@@ -1479,7 +1480,7 @@ function transformCall2ConsoleLog(node, calleeName, callee, options) {
 exports.transformCall2ConsoleLog = transformCall2ConsoleLog;
 function transformCall2Logging(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用', node);
     const newArguments = node.arguments.map((arg) => new utils_1.naslTypes.Argument({
         expression: arg?.name === "undefined" ?
             new utils_1.naslTypes.StringLiteral()
@@ -1511,7 +1512,7 @@ function transformCall2JSONFunctions(node, calleeName, callee, options) {
                 keyword: 'arg',
             }),
         ],
-        typeArguments: node?.typeParameters?.params.map((curType) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)({ ...curType })),
+        typeArguments: node?.typeParameters?.params.map((curType) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)({ ...curType }, options)).filter(Boolean),
     });
 }
 exports.transformCall2JSONFunctions = transformCall2JSONFunctions;
@@ -1528,7 +1529,7 @@ function transform2CallFunction(node, calleeName, argument, options) {
             keyword: func && func?.params[index]?.name || `param${index + 1}`,
         });
     });
-    let newTypeArguments = node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation);
+    let newTypeArguments = node?.typeParameters?.params.map((curType) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)({ ...curType }, options)).filter(Boolean);
     // if (calleeName === 'ListRepeat') {
     //   newTypeArguments = [
     //     new naslTypes.TypeAnnotation()
@@ -1562,7 +1563,7 @@ function transform2CallFunction(node, calleeName, argument, options) {
             const content = np?.toNaturalTS();
             const noContent = np?.toNaturalTS()?.includes('__IDENTIFIER__');
             if (!np && !p?.defaultExpression) {
-                (0, utils_1.throwError)(`函数${calleeName}生成不符合标准的函数调用`);
+                return (0, utils_1.throwError)(options?.parsingId, `函数${calleeName}生成不符合标准的函数调用`, content);
             }
             if (np && calleeName === 'ListDistinctBy') {
                 if (idx === 1) {
@@ -1595,7 +1596,7 @@ function transform2CallFunction(node, calleeName, argument, options) {
         });
     }
     else {
-        (0, utils_1.throwError)(`函数${calleeName}不存在`, node.callee);
+        return (0, utils_1.throwError)(options?.parsingId, `函数${calleeName}不存在`, node.callee, node);
     }
     if (!func.params?.length) {
         const needDefaultParam = ['CurrDate', 'CurrTime', 'CurrDateTime'];
@@ -1617,7 +1618,7 @@ function transform2CallFunction(node, calleeName, argument, options) {
         // 这两个参数比较特殊，可以无限加参数，不再判断参数数量
         const excludes = ['HasValue', 'ListSort'];
         if (func.params?.length !== newArguments?.length && !excludes.includes(calleeName)) {
-            (0, utils_1.throwError)(`函数${calleeName}生成不符合标准的函数调用，参数数量不匹配`);
+            return (0, utils_1.throwError)(options?.parsingId, `函数${calleeName}生成不符合标准的函数调用，参数数量不匹配`, node.callee, node);
         }
         else {
             newArguments?.forEach((arg, idx) => {
@@ -1634,17 +1635,18 @@ function transform2CallFunction(node, calleeName, argument, options) {
         // typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType, typeNamespace })),
     });
     if (calleeName === 'ListSort') {
-        return new utils_1.naslTypes.CallFunction((0, utils_1.handleListSort)(nodeElement?.toJSON()));
+        const handledNode = (0, utils_1.handleListSort)(nodeElement?.toJSON(), options);
+        return handledNode && new utils_1.naslTypes.CallFunction(handledNode);
     }
     if (options.transformType === 'logic' && options?.inCallQueryComponentField) {
-        (0, utils_1.throwError)('数据查询中不支持使用内置函数', nodeElement.calleeName, node);
+        return (0, utils_1.throwError)(options?.parsingId, '数据查询中不支持使用内置函数', nodeElement.calleeName, node);
     }
     return nodeElement;
 }
 exports.transform2CallFunction = transform2CallFunction;
 function transform2SqlFunction(node, calleeName, argument, options) {
     if (options.inCallQueryComponentField && !['WHERE', 'HAVING', 'ORDER_BY'].includes(options.inCallQueryComponentField)) {
-        (0, utils_1.throwError)(`数据查询中只有 WHERE, HAVING, ORDER_BY 支持 SQL 函数，而当前字段为 ${options.inCallQueryComponentField}`);
+        return (0, utils_1.throwError)(options?.parsingId, `数据查询中只有 WHERE, HAVING, ORDER_BY 支持 SQL 函数，而当前字段为 ${options.inCallQueryComponentField}`, node.callee, node);
     }
     const specFunList = ['COUNT', 'COUNTD', 'SUM', 'AVG', 'MAX', 'MIN'];
     // TODO: 先写死了 mysql，后续需要传入: 参考 requestSqlFunctions
@@ -1667,7 +1669,7 @@ function transform2SqlFunction(node, calleeName, argument, options) {
         calleeNamespace: 'nasl.sqlFunction',
         calleeName: utils_1.replaceCallFunctionMap?.[calleeName] || calleeName,
         arguments: [...addArguments, ...newArguments],
-        typeArguments: node?.typeParameters?.params.map(transform2TypeAnnotation_1.transform2TypeAnnotation),
+        typeArguments: node?.typeParameters?.params.map((curType) => (0, transform2TypeAnnotation_1.transform2TypeAnnotation)({ ...curType }, options)).filter(Boolean),
         // typeArguments: node?.typeParameters?.params.map((curType: any) => transform2TypeAnnotation({ ...curType, typeNamespace })),
     });
     return nodeElement;
@@ -1745,7 +1747,7 @@ function transform2UIFunction(node, calleeName, callee, options) {
         });
     }
     if (options?.isRestricted)
-        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: 'nasl.ui',
         calleeName: callee[2].name,
@@ -1782,11 +1784,11 @@ function transform2ForEachStatement(node, calleeName, callee, options) {
         each: transformNodeFunction(newCallee[0], options),
         start: transformNodeFunction(newCallee[1], options),
         end: newCallee[2]?.name === '__IDENTIFIER__' ? undefined : transformNodeFunction(newCallee[2], options),
-        item: arrowFunction?.params?.[0] ? transform2Param(arrowFunction.params[0]) : new utils_1.naslTypes.Param({
+        item: arrowFunction?.params?.[0] ? transform2Param(arrowFunction.params[0], options) || undefined : new utils_1.naslTypes.Param({
             name: 'item',
             typeAnnotation: undefined,
         }),
-        index: arrowFunction?.params?.[1] ? transform2Param(arrowFunction.params[1]) : new utils_1.naslTypes.Param({
+        index: arrowFunction?.params?.[1] ? transform2Param(arrowFunction.params[1], options) || undefined : new utils_1.naslTypes.Param({
             name: `index_${(0, utils_2.uuidv4)().slice(0, 4)}`,
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
@@ -1813,8 +1815,8 @@ function transformForOf2ForEachStatement(node, options) {
     let endNode;
     if (node?.right?.type === 'CallExpression') {
         const rightNode = node?.right;
-        const calleeName = rightNode?.callee?.type === 'Identifier' && rightNode?.callee?.name;
-        const hasListEntries = calleeName === 'ListEntries';
+        const calleeName = (0, utils_1.generate)(rightNode.callee).code;
+        const hasListEntries = ['ListEntries', 'nasl.util.ListEntries'].includes(calleeName);
         const areaArguments = rightNode?.arguments;
         eachNode = hasListEntries ? areaArguments?.[0] : rightNode;
         startNode = hasListEntries ? areaArguments?.[1] : undefined;
@@ -1830,11 +1832,11 @@ function transformForOf2ForEachStatement(node, options) {
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
         end: endNode?.name === '__IDENTIFIER__' ? undefined : endNode ? transformNodeFunction(endNode, options) : undefined,
-        item: itemNode ? transform2Param(itemNode) : new utils_1.naslTypes.Param({
+        item: itemNode ? transform2Param(itemNode, options) || undefined : new utils_1.naslTypes.Param({
             name: 'item',
             typeAnnotation: undefined,
         }),
-        index: indexNode ? transform2Param(indexNode) : new utils_1.naslTypes.Param({
+        index: indexNode ? transform2Param(indexNode, options) || undefined : new utils_1.naslTypes.Param({
             name: `index_${(0, utils_2.uuidv4)().slice(0, 2)}`,
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
@@ -1854,8 +1856,8 @@ function transformForEach2ForEachStatement(node, calleeName, callee, options) {
             value: '0',
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
-        item: transform2Param(arrowFunction.params[0]),
-        index: arrowFunction.params[1] ? transform2Param(arrowFunction.params[1]) : new utils_1.naslTypes.Param({
+        item: transform2Param(arrowFunction.params[0], options) || undefined,
+        index: arrowFunction.params[1] ? transform2Param(arrowFunction.params[1], options) || undefined : new utils_1.naslTypes.Param({
             name: `index_${(0, utils_2.uuidv4)().slice(0, 2)}`,
             typeAnnotation: utils_1.naslTypes.TypeAnnotation.createPrimitive('Long'),
         }),
@@ -1866,7 +1868,7 @@ function transformForEach2ForEachStatement(node, calleeName, callee, options) {
 exports.transformForEach2ForEachStatement = transformForEach2ForEachStatement;
 function transformAlert2ShowMessage(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: 'nasl.ui',
         calleeName: 'showMessage',
@@ -1879,7 +1881,7 @@ function transformAlert2ShowMessage(node, calleeName, callee, options) {
 exports.transformAlert2ShowMessage = transformAlert2ShowMessage;
 function transformCall2Interface(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        (0, utils_1.throwError)('调用接口不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, '调用接口不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallInterface({
         calleeNamespace: (0, utils_1.generate)(node.callee.object).code,
         calleeName: callee[callee.length - 1].name,
@@ -1892,14 +1894,14 @@ function transformCall2Interface(node, calleeName, callee, options) {
 exports.transformCall2Interface = transformCall2Interface;
 function transformCall2Connector(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        (0, utils_1.throwError)('调用连接器不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, '调用连接器不支持在组件或默认值表达式中使用', node);
     let calleeConnectionName = undefined;
     let calleeNamespace = undefined;
     let calleeNamespacePrefix = `connector.${callee[1].name}`;
     if (callee.length === 5) {
         const connectArg = callee[2].arguments[0];
         if (!connectArg || connectArg.type !== 'StringLiteral') {
-            (0, utils_1.throwError)('调用 connector 的 connect 参数不正确，只允许使用字符串字面量', node);
+            return (0, utils_1.throwError)(options?.parsingId, '调用 connector 的 connect 参数不正确，只允许使用字符串字面量', node);
         }
         calleeConnectionName = connectArg.value;
         const noNamespace = callee[3].name === 'logics';
@@ -1914,7 +1916,7 @@ function transformCall2Connector(node, calleeName, callee, options) {
         calleeNamespace = calleeNamespacePrefix;
     }
     else {
-        (0, utils_1.throwError)(`调用 connector，参数数量不正确，当前参数数量为 ${callee.length}，${calleeName}`, node);
+        return (0, utils_1.throwError)(options?.parsingId, `调用 connector，参数数量不正确，当前参数数量为 ${callee.length}，${calleeName}`, node);
     }
     return new utils_1.naslTypes.CallConnector({
         calleeConnectionName,
@@ -1928,7 +1930,7 @@ function transformCall2Connector(node, calleeName, callee, options) {
 exports.transformCall2Connector = transformCall2Connector;
 function transformCall2Extension(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        (0, utils_1.throwError)('调用扩展逻辑不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, '调用扩展逻辑不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: (0, utils_1.generate)(node?.callee?.object)?.code,
         calleeName: callee?.[callee?.length - 1]?.name,
@@ -1940,24 +1942,24 @@ function transformCall2Extension(node, calleeName, callee, options) {
 exports.transformCall2Extension = transformCall2Extension;
 function transformTSAsExpression(node, options) {
     if (node.expression.type === 'NumericLiteral') {
-        return transform2NumericLiteral(node.expression, { ...options, typeAnnotation: (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node.typeAnnotation) });
+        return transform2NumericLiteral(node.expression, { ...options, typeAnnotation: (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node.typeAnnotation, options) || undefined });
     }
     else if (node.expression.type === 'ArrayExpression') {
-        const typeAnnotation = (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node.typeAnnotation);
+        const typeAnnotation = (0, transform2TypeAnnotation_1.transform2TypeAnnotation)(node.typeAnnotation, options) || undefined;
         if (typeAnnotation.typeName !== 'List' && typeAnnotation.typeNamespace !== 'nasl.collection')
-            (0, utils_1.throwError)(`列表 as 必须为 List 类型`);
+            return (0, utils_1.throwError)(options?.parsingId, `列表 as 必须为 List 类型`, node);
         return transformArrayExpression(node.expression, { ...options, typeAnnotation });
     }
     else if (node.expression.type === 'NullLiteral') {
         return transform2NullLiteral(node.expression, options);
     }
     else {
-        (0, utils_1.throwError)('表达式不支持使用 as 关键字', node.expression.type, node.expression);
+        return (0, utils_1.throwError)(options?.parsingId, '表达式不支持使用 as 关键字', node.expression.type, node.expression);
     }
 }
 function transformCall2CallViewLogic(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        (0, utils_1.throwError)('调用页面逻辑不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, '调用页面逻辑不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: '',
         calleeName: calleeName.slice('viewLogic_'.length),
@@ -1969,7 +1971,7 @@ function transformCall2CallViewLogic(node, calleeName, callee, options) {
 exports.transformCall2CallViewLogic = transformCall2CallViewLogic;
 function transformCall2Logic(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用', node);
     if (utils_1.callFunctionMap.includes(calleeName)) {
         // 未带前缀，补一下
         return transform2CallFunction(node, calleeName, node?.arguments || [], options);
@@ -1995,7 +1997,7 @@ function transformCall2Logic(node, calleeName, callee, options) {
 exports.transformCall2Logic = transformCall2Logic;
 function transformCall2LogicWithAuth(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        (0, utils_1.throwError)('调用逻辑不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, '调用逻辑不支持在组件或默认值表达式中使用', node);
     return new utils_1.naslTypes.CallLogic({
         calleeNamespace: `nasl.auth`,
         calleeName: callee[callee.length - 1].name,
@@ -2020,10 +2022,10 @@ function flatCallQueryComponentChainNode(node, options) {
         const calleeName = node.callee.name;
         if (['FROM', 'INNER_JOIN', 'LEFT_JOIN', 'RIGHT_JOIN', 'OUTER_JOIN'].includes(calleeName)) {
             if (node.arguments[1].type !== 'ArrowFunctionExpression')
-                (0, utils_1.throwError)('FROM should have a ArrowFunctionExpression as the second argument', node.arguments[1]);
+                return (0, utils_1.throwError)(options?.parsingId, 'FROM should have a ArrowFunctionExpression as the second argument', node.arguments[1], node);
             const arrowFunctionExpression = node.arguments[1];
             if (arrowFunctionExpression.body.type !== 'CallExpression')
-                (0, utils_1.throwError)('FROM should have a CallExpression as the body of ArrowFunctionExpression', arrowFunctionExpression.body);
+                return (0, utils_1.throwError)(options?.parsingId, 'FROM should have a CallExpression as the body of ArrowFunctionExpression', arrowFunctionExpression.body, node);
             const body = arrowFunctionExpression.body;
             const callExpressions = flatChainCallExpression(body);
             const joinNode = callExpressions?.filter((item) => item?.callee?.name.includes('_JOIN'));
@@ -2033,13 +2035,13 @@ function flatCallQueryComponentChainNode(node, options) {
 FROM(T1Entity, T1 => ${name}(T2Entity, T2 => ON(T1.id == T2.id)).SELECT(...)); // 错误用法, ${name}的回调函数必须是完整的QueryChain
 FROM(T1Entity, T1 => ${name}(T2Entity, T2 => ON(T1.id == T2.id).SELECT(...))); // 正确用法, 后续查询都在${name}的回调函数中进行
 `;
-                (0, utils_1.throwError)(error);
+                return (0, utils_1.throwError)(options?.parsingId, error, node);
             }
             const joinCode = (0, utils_1.generate)(joinNode[0])?.code || '';
             const count = joinCode.match(/_JOIN/g)?.length || 0;
             const errorOrder = count >= 1 && !callExpressions?.[callExpressions?.length - 1]?.callee?.name?.includes('_JOIN');
             if (errorOrder) {
-                (0, utils_1.throwError)('调用顺序错误，期望的调用顺序为 FROM -> JOIN -> WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY。其中，FROM在最外层，FROM内部是零到多层JOIN嵌套调用，在最内层的JOIN内部是 WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY 的调用顺序。');
+                return (0, utils_1.throwError)(options?.parsingId, '调用顺序错误，期望的调用顺序为 FROM -> JOIN -> WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY。其中，FROM在最外层，FROM内部是零到多层JOIN嵌套调用，在最内层的JOIN内部是 WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY 的调用顺序。', node);
             }
             const result = [{
                     calleeName: calleeName,
@@ -2051,7 +2053,7 @@ FROM(T1Entity, T1 => ${name}(T2Entity, T2 => ON(T1.id == T2.id).SELECT(...))); /
                         result[0].arguments[2] = item.arguments[0];
                     }
                     else if (['INNER_JOIN', 'LEFT_JOIN', 'RIGHT_JOIN', 'OUTER_JOIN'].includes(item.callee.name)) {
-                        result.push(...flatCallQueryComponentChainNode(item, options));
+                        result.push(...flatCallQueryComponentChainNode(item, options) || []);
                     }
                     else {
                         result.push({
@@ -2084,37 +2086,37 @@ function flatOnExpressions(node) {
         return [node];
     }
 }
-function transformMemberExpression2Entity(node, node2) {
+function transformMemberExpression2Entity(node, node2, options) {
     const entityPath = flatMemberExpression(node);
     const entityNamespace = entityPath.slice(0, -1).map(n => n.name).join('.');
     const entityName = entityPath[entityPath.length - 1].name.replace(/Entity$/, '');
     if (!entityNamespace?.includes('.entities')) {
-        (0, utils_1.throwError)(`${entityNamespace}.${entityName} 不是一个数据库表，无法使用数据查询`);
+        return (0, utils_1.throwError)(options?.parsingId, `${entityNamespace}.${entityName} 不是一个数据库表，无法使用数据查询`, node);
     }
     const asName = node2.name === entityName ? undefined : node2.name;
     if (asName) {
-        (0, utils_1.throwError)(`FROM 中回调函数的入参名称应为${entityName}，但实际为${node2.name}`);
+        return (0, utils_1.throwError)(options?.parsingId, `FROM 中回调函数的入参名称应为${entityName}，但实际为${node2.name}`);
     }
     return { entityNamespace, entityName, asName };
 }
 function transformCall2DataQuery(node, calleeName, callee, options) {
     if (options?.isInFrontend)
-        (0, utils_1.throwError)('数据查询组件不支持在前端使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, '数据查询组件不支持在前端使用', node);
     if (options?.isRestricted)
-        (0, utils_1.throwError)('数据查询组件不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, '数据查询组件不支持在组件或默认值表达式中使用', node);
     const transformNodeFunction = options?.transformNodeFunction || transform2LogicItem;
     const code = (0, utils_1.generate)(node)?.code || '';
     if (code?.includes('nasl.util')) {
-        (0, utils_1.throwError)('数据查询中不支持nasl.util内的库函数，请将对应操作放在数据查询外部进行处理', code);
+        return (0, utils_1.throwError)(options?.parsingId, '数据查询中不支持nasl.util内的库函数，请将对应操作放在数据查询外部进行处理', code);
     }
     if (!code?.includes('.SELECT(') && !code?.includes('.AGGR_SELECT(')) {
-        (0, utils_1.throwError)('缺少 SELECT 或 AGGR_SELECT 语句', code);
+        return (0, utils_1.throwError)(options?.parsingId, '缺少 SELECT 或 AGGR_SELECT 语句', code);
     }
     const flatted = flatCallQueryComponentChainNode(node, options);
-    const calleeNames = flatted.map((item) => item?.calleeName).filter((name) => name !== '$');
+    const calleeNames = flatted && flatted.map((item) => item?.calleeName).filter((name) => name !== '$');
     const isOrderCorrect = (0, utils_1.checkOQLCalleeNameOrder)(calleeNames);
     if (!isOrderCorrect) {
-        (0, utils_1.throwError)('调用顺序错误，期望的调用顺序为 FROM -> JOIN -> WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY。其中，FROM在最外层，FROM内部是零到多层JOIN嵌套调用，在最内层的JOIN内部是 WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY 的调用顺序。');
+        return (0, utils_1.throwError)(options?.parsingId, '调用顺序错误，期望的调用顺序为 FROM -> JOIN -> WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY。其中，FROM在最外层，FROM内部是零到多层JOIN嵌套调用，在最内层的JOIN内部是 WHERE -> GROUP_BY -> SELECT/AGGR_SELECT -> HAVING -> ORDER_BY 的调用顺序。', node);
     }
     let from;
     let where;
@@ -2127,11 +2129,13 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
     let hasErrorTSScopeColumn = false;
     let useResultItem = false;
     // 这里只是一个示例，具体的逻辑需要根据flatted的内容来构建
-    flatted.forEach((item) => {
+    flatted && flatted.forEach((item) => {
         // console.log(item.calleeName)
         switch (item.calleeName) {
             case 'FROM':
-                entity = transformMemberExpression2Entity(item.arguments[0], item.arguments[1]);
+                entity = transformMemberExpression2Entity(item.arguments[0], item.arguments[1], options);
+                if (!entity)
+                    return;
                 const entityName = entity.asName || entity.entityName;
                 entityAsNames.push(entityName);
                 from = new utils_1.naslTypes.QueryFromExpression({
@@ -2143,11 +2147,15 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
             case 'LEFT_JOIN':
             case 'RIGHT_JOIN':
             case 'OUTER_JOIN':
-                entity = transformMemberExpression2Entity(item.arguments[0], item.arguments[1]);
+                entity = transformMemberExpression2Entity(item.arguments[0], item.arguments[1], options);
+                if (!entity)
+                    break;
                 entityAsNames.push(entity.asName || entity.entityName);
                 const rawJoinType = item.calleeName.slice(0, -5);
                 const joinType = rawJoinType === 'OUTER' ? 'FULL' : rawJoinType;
                 const onExpressions = flatOnExpressions(item.arguments[2]);
+                if (!from)
+                    return; // throwError(options?.parsingId, 'FROM 不存在或异常，无法添加 JOIN 子句', node);
                 from.addJoinPart(new utils_1.naslTypes.QueryJoinExpression({
                     ...entity,
                     joinType,
@@ -2164,14 +2172,14 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                 break;
             case 'AGGR_SELECT':
                 if (groupBy?.length) {
-                    (0, utils_1.throwError)('存在 GROUP_BY，应使用 SELECT 进行查询，但实际为 AGGR_SELECT');
+                    return (0, utils_1.throwError)(options?.parsingId, '存在 GROUP_BY，应使用 SELECT 进行查询，但实际为 AGGR_SELECT', node);
                 }
                 select = new utils_1.naslTypes.QuerySelectExpression({
                     distinct: false,
                     star: true,
                     selectElements: [new utils_1.naslTypes.QueryFieldExpression({
                             isDotStar: true,
-                            entityAsName: from.entityName,
+                            entityAsName: from?.entityName,
                             propertyName: '',
                         })],
                 });
@@ -2179,11 +2187,13 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                     item.arguments[0].properties?.forEach((arg) => {
                         if (arg?.value.type === 'CallExpression') {
                             let selectElements = transform2QueryAggregateExpression(arg, { ...options, entityAsNames, inCallQueryComponentField: item.calleeName });
-                            const newSelectElements = [...select.selectElements, selectElements];
-                            select.setSelectElements(newSelectElements);
+                            if (selectElements) {
+                                const newSelectElements = [...select.selectElements, selectElements];
+                                select.setSelectElements(newSelectElements);
+                            }
                         }
                         else {
-                            (0, utils_1.throwError)(`Unsupported expression type for QueryAggregateExpression`, arg?.value.type, arg?.value);
+                            return (0, utils_1.throwError)(options?.parsingId, `Unsupported expression type for QueryAggregateExpression`, arg?.value.type, arg?.value);
                         }
                     });
                 }
@@ -2198,11 +2208,13 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                         computed: false,
                         shorthand: false,
                     }, { ...options, entityAsNames, inCallQueryComponentField: item.calleeName });
-                    const newSelectElements = [...select.selectElements, selectElements];
-                    select.setSelectElements(newSelectElements);
+                    if (selectElements) {
+                        const newSelectElements = [...select.selectElements, selectElements];
+                        select.setSelectElements(newSelectElements);
+                    }
                 }
                 else {
-                    (0, utils_1.throwError)('Unsupported expression type for QueryAggregateExpression', item.arguments[0].type, item.arguments[0]);
+                    return (0, utils_1.throwError)(options?.parsingId, 'Unsupported expression type for QueryAggregateExpression', item.arguments[0].type, item.arguments[0]);
                 }
                 break;
             case 'SELECT':
@@ -2211,7 +2223,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                     star: true,
                     selectElements: groupBy?.length ? [new utils_1.naslTypes.QueryFieldExpression({
                             isDotStar: true,
-                            entityAsName: from.entityName,
+                            entityAsName: from?.entityName,
                             propertyName: '',
                         })] : [],
                 });
@@ -2222,17 +2234,17 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                     }
                     else if (arg.value.type === 'ObjectExpression') {
                         if (groupBy?.length) {
-                            (0, utils_1.throwError)('存在 GROUP_BY，SELECT应为单层结构，不应使用双层局部列');
+                            return (0, utils_1.throwError)(options?.parsingId, '存在 GROUP_BY，SELECT应为单层结构，不应使用双层局部列', node);
                         }
                         const originName = arg.key?.name || '';
                         if (originName && originName.charAt(0) === originName.charAt(0).toUpperCase()) {
                             const needName = (0, utils_2.firstLowerCase)(originName);
-                            (0, utils_1.throwError)(`SELECT 局部列第一层命名不符合规范, 应为${needName}, 但实际为${originName}`);
+                            return (0, utils_1.throwError)(options?.parsingId, `SELECT 局部列第一层命名不符合规范, 应为${needName}, 但实际为${originName}`, node);
                         }
                         const entityName = (0, utils_2.firstUpperCase)(originName);
                         const needNameList = entityAsNames.map(item => (0, utils_2.firstLowerCase)(item))?.join('或');
                         if (!entityAsNames.includes(entityName)) {
-                            (0, utils_1.throwError)(`SELECT 局部列第一层命名不符合规范, 应为${needNameList}, 但实际为${originName}`);
+                            return (0, utils_1.throwError)(options?.parsingId, `SELECT 局部列第一层命名不符合规范, 应为${needNameList}, 但实际为${originName}`, node);
                         }
                         selectElements = arg.value.properties?.map((property) => {
                             const columnAsName = property.key?.name;
@@ -2240,7 +2252,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                             const selectElement = transform2SelectQueryFieldExpression(property, { ...options, entityAsNames, inCallQueryComponentField: item.calleeName });
                             if (columnAsName !== columnPropertyName) {
                                 // eg: comment: Topic_Comment.comment_stu
-                                (0, utils_1.throwError)(`SELECT 局部列第二层命名不符合规范, 应为${columnPropertyName}, 但实际为${columnAsName}`);
+                                return (0, utils_1.throwError)(options?.parsingId, `SELECT 局部列第二层命名不符合规范, 应为${columnPropertyName}, 但实际为${columnAsName}`, node);
                             }
                             selectElement.isDotStar = false;
                             return selectElement;
@@ -2275,7 +2287,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                     }
                 }
                 else {
-                    (0, utils_1.throwError)('HAVING 不符合规范，请使用箭头函数', havingNode);
+                    return (0, utils_1.throwError)(options?.parsingId, 'HAVING 不符合规范，请使用箭头函数', havingNode, node);
                 }
                 having = transformNodeFunction(havingNode, { ...options, ...restParams });
                 break;
@@ -2290,7 +2302,7 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
                     }
                 }
                 else {
-                    (0, utils_1.throwError)('ORDER_BY 不符合规范，请使用箭头函数', orderNode);
+                    return (0, utils_1.throwError)(options?.parsingId, 'ORDER_BY 不符合规范，请使用箭头函数', orderNode, node);
                 }
                 orderBy = orderNode.map((arg) => {
                     let orderElementCode = (0, utils_1.generate)(arg)?.code || '';
@@ -2316,26 +2328,26 @@ function transformCall2DataQuery(node, calleeName, callee, options) {
         ideVersion: '2.22',
     });
     if (hasErrorTSScopeColumn && !groupBy?.length && !having) {
-        (0, utils_1.throwError)('SELECT 局部列不符合规范，需要按两层对象返回');
+        return (0, utils_1.throwError)(options?.parsingId, 'SELECT 局部列不符合规范，需要按两层对象返回', node);
     }
     const hasScopeColumn = select?.selectElements?.find((selectElement) => selectElement?.concept === 'QueryFieldExpression' && !selectElement?.isDotStar);
     if (hasScopeColumn && (groupBy?.length || having)) {
-        (0, utils_1.throwError)('分组聚合与表字段局部列不允许同时出现');
+        return (0, utils_1.throwError)(options?.parsingId, '分组聚合与表字段局部列不允许同时出现', node);
     }
     if (hasScopeColumn && useResultItem) {
-        (0, utils_1.throwError)("对于局部列的排序，只支持 实体.属性名 的格式，例如 ORDER_BY((resultItem) => [[Student.age, 'ASC']])");
+        return (0, utils_1.throwError)(options?.parsingId, "对于局部列的排序，只支持 实体.属性名 的格式，例如 ORDER_BY((resultItem) => [[Student.age, 'ASC']])", node);
     }
     const isOnlyAggr = select?.selectElements?.find((selectElement) => selectElement?.concept !== 'QueryAggregateExpression');
     // 如果 select 中只有聚合属性时，并且没有用 AGGR_SELECT 来指定列
     if (!isOnlyAggr && !calleeNames?.includes('AGGR_SELECT')) {
-        (0, utils_1.throwError)('SELECT 不符合规范，请使用 AGGR_SELECT');
+        return (0, utils_1.throwError)(options?.parsingId, 'SELECT 不符合规范，请使用 AGGR_SELECT', node);
     }
     // callQueryComponent.typeAnnotation = callQueryComponent.computeStructure();
     return callQueryComponent;
 }
 function transformCall2LaunchProcess(node, calleeName, callee, options) {
     if (options?.isRestricted)
-        (0, utils_1.throwError)('调用流程逻辑不支持在组件或默认值表达式中使用', node);
+        return (0, utils_1.throwError)(options?.parsingId, '调用流程逻辑不支持在组件或默认值表达式中使用', node);
     const args = node.arguments;
     const dataArg = args?.[0];
     const procDefKeyArg = args?.[1];
@@ -2442,7 +2454,7 @@ function transform2LogicItem(node, options) {
     transformManager.registerCallExpression((node, calleeName, callee) => callee.length === 1 && !['ArrowFunctionExpression', 'FunctionExpression'].includes(callee[0].type), transformCall2Logic);
     let result = transformManager.apply(node, options);
     delete options.typeAnnotation;
-    return result;
+    return result || undefined;
 }
 exports.transform2LogicItem = transform2LogicItem;
 //# sourceMappingURL=transform2LogicItem.js.map