@lcap/nasl 3.8.3-beta.1 → 3.8.3-beta.2

package/src/concepts/BusinessComponent__.ts

@@ -46,6 +46,7 @@ import Variable from './Variable__';
 import BindEvent from './BindEvent__';
 import BusinessLogic from './BusinessLogic__';
 import ViewElement from './ViewElement__';
+import { reCollectTyInferCtx } from '../../../nasl/src/server/semanticData';
 
 /**
  * 业务组件
@@ -1999,53 +2000,7 @@ export class BusinessComponent extends BaseNode {
 
     const advanceMap: Map<Variable, Assignment | BatchAssignment> = new Map();
     const callFunctionAdvanceMap: Map<Variable, CallFunction> = new Map();
-    yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
-      if (
-        el &&
-        // 批量赋值
-        (asserts.isBatchAssignment(el) ||
-          // 赋值
-          (asserts.isAssignment(el) && el.left?.name) ||
-          // 内置函数对集合类型的推导
-          (asserts.isCallFunction(el) && el.derivablecollection?.name))
-      ) {
-        if (el?.getAncestor('SubLogic')) {
-          return;
-        }
-        if (asserts.isAssignment(el)) {
-          const advanceVar = self.variables?.find(
-            (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
-          );
-          if (advanceVar && !advanceMap.get(advanceVar)) {
-            advanceMap.set(advanceVar, el);
-          }
-        } else if (asserts.isCallFunction(el)) {
-          // 需要被推导的集合
-          const expression = el.derivablecollection;
-          const advanceVar = self.variables?.find((variable) => {
-            return !variable.typeAnnotation && expression?.name === variable.name;
-          });
-          if (advanceVar && !callFunctionAdvanceMap.get(advanceVar)) {
-            callFunctionAdvanceMap.set(advanceVar, el);
-          }
-        } else if (asserts.isBatchAssignment(el)) {
-          yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
-            const leftCode =
-              leftIndex.length === 1
-                ? yield* el.left?.expression?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                    returnOrigin('')
-                : yield* el.left?.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                    returnOrigin('');
-            const advanceVar = self.variables?.find(
-              (variable) => !variable.typeAnnotation && leftCode === variable.name,
-            );
-            if (advanceVar && !advanceMap.get(advanceVar)) {
-              advanceMap.set(advanceVar, el);
-            }
-          });
-        }
-      }
-    });
+    yield* reCollectTyInferCtx(advanceMap, callFunctionAdvanceMap, self);
 
     // 用来储存默认值翻译结构是__IDENTIFIER__或者__IDENTIFIER__()的节点
     const IDENTIFIERMAP = new Set<Variable>();
@@ -2155,7 +2110,7 @@ export class BusinessComponent extends BaseNode {
                 && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
               )
               || (
-                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode)) 
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode))
                 && !(itemNode?.typeAnnotation)
               )
             ) {
@@ -2523,11 +2478,11 @@ export class BusinessComponent extends BaseNode {
   @withSourceMap()
   toTextualNASL(state = createCompilerState()): string {
     let code = '';
-    
+
     code += createDecoratorCode(state, this, ['title', 'description']);
 
     code += `viewComponent ${this.name}`;
-    
+
     code += `(\n`;
     this.params.forEach((param, index) => {
       code += param.toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 }));
@@ -2551,7 +2506,7 @@ export class BusinessComponent extends BaseNode {
       code += '\n';
     });
     if (this.logics.length) code += '\n';
-    
+
     code += this.elements[0].toTextualNASL(shiftState(state, code, { tabSize: state.tabSize + 1 }));
 
     code += `\n${indent(state.tabSize)}}`;

package/src/concepts/BusinessLogic__.ts

@@ -25,6 +25,7 @@ import * as types from './utils/types';
 import * as asserts from './utils/asserts';
 
 import Logic from './Logic__';
+import { reCollectTyInferCtx } from '../../../nasl/src/server/semanticData';
 
 /**
  * 业务组件逻辑
@@ -135,61 +136,8 @@ export class BusinessLogic extends Logic {
     // 需要类型推导的局部变量/返回值需要调整申明顺序
     const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
     const callFunctionAdvanceMap: Map<Return | Variable, CallFunction> = new Map();
-    yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
-      if (
-        el &&
-        // 批量赋值
-        (asserts.isBatchAssignment(el) ||
-          // 赋值
-          (asserts.isAssignment(el) && el.left?.name) ||
-          // 内置函数对集合类型的推导
-          (asserts.isCallFunction(el) && el.derivablecollection?.name))
-      ) {
-        if (el?.getAncestor('SubLogic')) {
-          return;
-        }
-        if (asserts.isAssignment(el)) {
-          const advanceVar = self.variables?.find(
-            (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
-          );
-          if (advanceVar && !advanceMap.get(advanceVar)) {
-            advanceMap.set(advanceVar, el);
-          }
-          const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && el.left?.name === ret.name);
-          if (advanceRn && !advanceMap.get(advanceRn)) {
-            advanceMap.set(advanceRn, el);
-          }
-        } else if (asserts.isCallFunction(el)) {
-          // 需要被推导的集合
-          const expression = el.derivablecollection;
-          // 宽泛意义上的变量（变量+出参）
-          const advanceVar = [...(self.variables || []), ...(self.returns || [])].find((variable) => {
-            return !variable.typeAnnotation && expression?.name === variable.name;
-          });
-          if (advanceVar && !callFunctionAdvanceMap.get(advanceVar)) {
-            callFunctionAdvanceMap.set(advanceVar, el);
-          }
-        } else if (asserts.isBatchAssignment(el)) {
-          yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
-            const leftCode =
-              leftIndex.length === 1
-                ? yield* el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
-                : yield* el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                    returnOrigin('');
-            const advanceVar = self.variables?.find(
-              (variable) => !variable.typeAnnotation && leftCode === variable.name,
-            );
-            if (advanceVar && !advanceMap.get(advanceVar)) {
-              advanceMap.set(advanceVar, el);
-            }
-            const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && leftCode === ret.name);
-            if (advanceRn && !advanceMap.get(advanceRn)) {
-              advanceMap.set(advanceRn, el);
-            }
-          });
-        }
-      }
-    });
+    yield* reCollectTyInferCtx(advanceMap, callFunctionAdvanceMap, self);
+
     // 兼容 return 没有类型情况
     if (self.returns.length && self.returns[0].typeAnnotation) {
       code += ': ';
@@ -360,7 +308,7 @@ export class BusinessLogic extends Logic {
                 && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
               )
               || (
-                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode)) 
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode))
                 && !(itemNode?.typeAnnotation)
               )
             ) {

package/src/concepts/CallFunction__.ts

@@ -787,7 +787,7 @@ export class CallFunction extends LogicItem {
   }
 
   // 集合
-  get derivablecollection() {
+  get derivableCollection() {
     if (this.isDerivableCollection) {
       return this.arguments?.[0]?.expression;
     }

package/src/concepts/Identifier__.ts

@@ -1,4 +1,3 @@
-import { wrapForEachToGenerator as wrapForEach } from '../utils/time-slicing';
 import {
   TranslatorState,
   withSourceMap,
@@ -30,6 +29,7 @@ import * as types from './utils/types';
 import * as asserts from './utils/asserts';
 
 import LogicItem from './LogicItem__';
+import { varScopeCtx } from '../../../nasl/src/server/semanticData';
 
 /**
  * 标识符
@@ -97,7 +97,30 @@ export class Identifier extends LogicItem {
     return findConceptKeyWordByNamespace(this.namespace) === 'enums';
   }
 
+  get view() {
+    if (varScopeCtx.isFirstScreen) {
+      return varScopeCtx.idToView.get(this);
+    } else {
+      return this.getAncestor('View') as View;
+    }
+  }
+
+  /*
+  种类              namespace
+  后端全局变量  app.backend.variables
+  后端局部变量  undefined
+  前端局部变量  ""
+  前端页面变量  ""
+  前端全局变量  app.frontendTypes.pc.frontends.pc.variables
+  */
+  // 热点代码，优化前占首屏时间 7.4%（赫基 3.2s）
   get isFrontendVariables() {
+    if (varScopeCtx.isFirstScreen) {
+      if (!varScopeCtx.frontendGlobalVars.has(this.name)) {
+        return false;
+      }
+    }
+
     const frontendType = this.getAncestor('FrontendType') as FrontendType;
     return (
       this.namespace?.startsWith(`app.frontendTypes.${frontendType?.kind}.frontends`) &&
@@ -223,6 +246,26 @@ export class Identifier extends LogicItem {
     );
   }
 
+
+  fastIsViewOrGlobalDataVariable() {
+    const { parentNode, namespace, jsName: name } = this;
+    const isMemberExpressionProperty =
+      parentNode?.concept === 'MemberExpression' && this.parentKey === 'property';
+    if (isMemberExpressionProperty) {
+      return false;
+    }
+
+    const nameInComponentLike = varScopeCtx.varInViewOrComponent.has(name) || varScopeCtx.logicInViewOrComponent.has(name);
+    return nameInComponentLike ||
+        this.globalDataMap[name] ||
+        namespace?.endsWith('nasl.browser') ||
+        namespace?.endsWith('nasl.auth') ||
+        namespace?.endsWith('nasl.configuration') ||
+        namespace?.endsWith('nasl.process') ||
+        this.isEnum() ||
+        this.isFrontendVariables;
+  }
+
   toBrief(): string {
     return this.name || '-';
   }
@@ -234,17 +277,25 @@ export class Identifier extends LogicItem {
   @withSourceMapGenerator
   *toEmbeddedTS(state = createCompilerState(), options?: any): TranslatorGenerator {
     const self = this;
-    const view = this.getAncestor('View') as View;
-    // 属于页面下 的变量
-    if (view && this.isViewOrGlobalDataVariable) {
+
+    let test : boolean;
+    if (varScopeCtx.isFirstScreen) {
+      test = this.fastIsViewOrGlobalDataVariable();
+    } else {
+      test = self.view && this.isViewOrGlobalDataVariable();
+    }
+
+    // 热点代码，优化前占首屏时间为 11.1%（4.8s）
+    // 属于页面下的变量
+    if (test) {
       // 变量名是否与流程名一致
       const processV2 = this.app?.processV2s.find((processV2) => {
         return processV2.name === this.name;
       });
       if (processV2) {
         let matched = false;
-        const viewNamespace = view.getNamespace();
-        const viewName = view.name;
+        const viewNamespace = self.view.getNamespace();
+        const viewName = self.view.name;
         processV2.traverseChildren((node) => {
           if (node?.concept === 'Destination') {
             const { viewNamespace: desViewNamespace, viewName: desViewName } = node;

package/src/concepts/Logic__.ts

@@ -49,6 +49,9 @@ import type CallFunction from './CallFunction__';
 import ProcessElementV2 from './ProcessElementV2__';
 import ProcessV2 from './ProcessV2__';
 import type SubLogic from './SubLogic__';
+
+import { reCollectTyInferCtx, varScopeCtx } from '../../../nasl/src/server/semanticData';
+
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
 // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓
@@ -1568,63 +1571,9 @@ export class Logic extends Annotatable {
     // 需要类型推导的局部变量/返回值需要调整申明顺序
     const advanceMap: Map<Return | Variable, Assignment | BatchAssignment | CallFunction> = new Map();
     const callFunctionAdvanceMap: Map<Return | Variable, CallFunction> = new Map();
+    yield* reCollectTyInferCtx(advanceMap, callFunctionAdvanceMap, self);
+
     const IDENTIFIERMAP = new Set<Variable | Return>();
-    // const needGetSourceMapOqlList: Promise<any>[] = [];
-    yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
-      if (
-        el &&
-        // 批量赋值
-        (asserts.isBatchAssignment(el) ||
-          // 赋值
-          (asserts.isAssignment(el) && el.left?.name) ||
-          // 内置函数对集合类型的推导
-          (asserts.isCallFunction(el) && el.derivablecollection?.name))
-      ) {
-        if (el?.getAncestor('SubLogic')) {
-          return;
-        }
-        if (asserts.isAssignment(el)) {
-          const advanceVar = self.variables?.find(
-            (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
-          );
-          if (advanceVar && !advanceMap.get(advanceVar)) {
-            advanceMap.set(advanceVar, el);
-          }
-          const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && el.left?.name === ret.name);
-          if (advanceRn && !advanceMap.get(advanceRn)) {
-            advanceMap.set(advanceRn, el);
-          }
-        } else if (asserts.isCallFunction(el)) {
-          // 需要被推导的集合
-          const expression = el.derivablecollection;
-          // 宽泛意义上的变量（变量+出参）
-          const advanceVar = [...(self.variables || []), ...(self.returns || [])].find((variable) => {
-            return !variable.typeAnnotation && expression?.name === variable.name;
-          });
-          if (advanceVar && !callFunctionAdvanceMap.get(advanceVar)) {
-            callFunctionAdvanceMap.set(advanceVar, el);
-          }
-        } else if (asserts.isBatchAssignment(el)) {
-          yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
-            const leftCode =
-              leftIndex.length === 1
-                ? yield* el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
-                : yield* el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                returnOrigin('');
-            const advanceVar = self.variables?.find(
-              (variable) => !variable.typeAnnotation && leftCode === variable.name,
-            );
-            if (advanceVar && !advanceMap.get(advanceVar)) {
-              advanceMap.set(advanceVar, el);
-            }
-            const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && leftCode === ret.name);
-            if (advanceRn && !advanceMap.get(advanceRn)) {
-              advanceMap.set(advanceRn, el);
-            }
-          });
-        }
-      }
-    });
 
     for (const variable of self.variables) {
       const ts = yield* variable.defaultValue?.toEmbeddedTS?.() ?? utils.returnOrigin('');
@@ -1894,61 +1843,7 @@ export class Logic extends Annotatable {
     // 需要类型推导的局部变量/返回值需要调整申明顺序
     const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
     const callFunctionAdvanceMap: Map<Return | Variable, CallFunction> = new Map();
-    yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
-      if (
-        el &&
-        // 批量赋值
-        (asserts.isBatchAssignment(el) ||
-          // 赋值
-          (asserts.isAssignment(el) && el.left?.name) ||
-          // 内置函数对集合类型的推导
-          (asserts.isCallFunction(el) && el.derivablecollection?.name))
-      ) {
-        if (el?.getAncestor('SubLogic')) {
-          return;
-        }
-        if (asserts.isAssignment(el)) {
-          const advanceVar = self.variables?.find(
-            (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
-          );
-          if (advanceVar && !advanceMap.get(advanceVar)) {
-            advanceMap.set(advanceVar, el);
-          }
-          const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && el.left?.name === ret.name);
-          if (advanceRn && !advanceMap.get(advanceRn)) {
-            advanceMap.set(advanceRn, el);
-          }
-        } else if (asserts.isCallFunction(el)) {
-          // 需要被推导的集合
-          const expression = el.derivablecollection;
-          // 宽泛意义上的变量（变量+出参）
-          const advanceVar = [...(self.variables || []), ...(self.returns || [])].find((variable) => {
-            return !variable.typeAnnotation && expression?.name === variable.name;
-          });
-          if (advanceVar && !callFunctionAdvanceMap.get(advanceVar)) {
-            callFunctionAdvanceMap.set(advanceVar, el);
-          }
-        } else if (asserts.isBatchAssignment(el)) {
-          yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
-            const leftCode =
-              leftIndex.length === 1
-                ? yield* el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
-                : yield* el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                returnOrigin('');
-            const advanceVar = self.variables?.find(
-              (variable) => !variable.typeAnnotation && leftCode === variable.name,
-            );
-            if (advanceVar && !advanceMap.get(advanceVar)) {
-              advanceMap.set(advanceVar, el);
-            }
-            const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && leftCode === ret.name);
-            if (advanceRn && !advanceMap.get(advanceRn)) {
-              advanceMap.set(advanceRn, el);
-            }
-          });
-        }
-      }
-    });
+    yield* reCollectTyInferCtx(advanceMap, callFunctionAdvanceMap, self);
 
     const needChooseParamTypes = completeTypeParams.filter((typeParam) => typeParam.needChoose);
     // 兼容 return 没有类型情况
@@ -2914,6 +2809,9 @@ export class Logic extends Annotatable {
   subLogics: Array<SubLogic> = [];
 
   getSubLogics() {
+    if (varScopeCtx.isFirstScreen) {
+      return;
+    }
     const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
       if (node?.concept === 'SubLogic') {
         return true;

package/src/concepts/MemberExpression__.ts

@@ -125,7 +125,7 @@ export class MemberExpression extends LogicItem {
       let elementTag;
 
       if (this.object?.namespace?.startsWith('elements.$ce')) {
-        elementName = this.getAncestor('ViewElement')?.name;
+        elementName = this.getAncestor('ViewElement')?.name
       } else {
         elementName = this.object.name;
       }
@@ -173,7 +173,7 @@ export class MemberExpression extends LogicItem {
       this.object?.object?.name === 'elements' &&
       this.object?.property?.name === '$ce'
     ) {
-      return this.transfromAtrrLogic({ type: 'toVue' });
+      return this.transformAtrrLogic({ type: 'toVue' });
     }
 
     const object = String(this.object?.toVue(options)); // undefined 也让正常展示
@@ -302,7 +302,7 @@ export class MemberExpression extends LogicItem {
       this.object?.object?.name === 'elements' &&
       this.object?.property?.name === '$ce'
     ) {
-      return this.transfromAtrrLogic();
+      return this.transformAtrrLogic();
     }
 
     const object: string = this.object?.toJS(state);
@@ -409,10 +409,13 @@ export class MemberExpression extends LogicItem {
     return value;
   }
 
-  transfromAtrrLogic(options?: { type: 'toVue' | 'toJS' }) {
+  transformAtrrLogic(options?: { type: 'toVue' | 'toJS' }) {
     const { type = 'toJS' } = options || {};
 
-    const elementName = this.getAncestor('ViewElement')?.name;
+    const elementName = this.getAncestor('ViewElement')?.name
+    // varScopeCtx.isFirstScreen
+    //     ? varScopeCtx.memExprToViewElem.get(this)?.name
+    //     : this.getAncestor('ViewElement')?.name;
     let element;
     let elementTag;
 
@@ -490,6 +493,17 @@ export class MemberExpression extends LogicItem {
   *toEmbeddedTS(state = createCompilerState()): TranslatorGenerator {
     const self = this;
     let code = '';
+
+    // 变量提升且是调用逻辑取属性，此时需要翻译为立即执行函数规避 TS 的 BUG
+    if (asserts.isCallLogic(self.object) && state.isVariableHost) {
+      code += '(() => {\nconst __$1 = ';
+      code += `${yield* self.object.toEmbeddedTS(shiftState(state, code, { inline: true }))};\n`
+      code += `return __$1.`;
+      code += self.property ? yield* self.property.toEmbeddedTS(shiftState(state, code, { inline: true })) : '';
+      code += ';})()';
+      return code;
+    }
+
     const leftCode = self.object
       ? `${yield* self.object.toEmbeddedTS(shiftState(state, code, { inline: true }))}.`
       : '';
@@ -516,7 +530,7 @@ export class MemberExpression extends LogicItem {
     ) {
       let newCode = '';
       if (self.object?.namespace?.startsWith('elements.$ce')) {
-        const elementName = self.getAncestor('ViewElement')?.name;
+        const elementName = self.getAncestor('ViewElement')?.name
         newCode += `__elements['${elementName}']`;
         if (asserts.isIdentifier(self.property) && self.property?.name) {
           newCode += `['${self.property?.name}']`;
@@ -537,7 +551,7 @@ export class MemberExpression extends LogicItem {
       self.object?.property?.name === '$ce'
     ) {
       let newCode = '';
-      const elementName = self.getAncestor('ViewElement')?.name;
+      const elementName = self.getAncestor('ViewElement')?.name
       newCode += `__elements['${elementName}']`;
       newCode += `.${self.property?.name}`;
       return newCode;

package/src/concepts/OverriddenLogic__.ts

@@ -59,6 +59,7 @@ import Param from './Param__';
 import Return from './Return__';
 import Variable from './Variable__';
 import LogicItem from './LogicItem__';
+import { reCollectTyInferCtx } from '../../../nasl/src/server/semanticData';
 
 /**
  * 覆写逻辑
@@ -1584,61 +1585,8 @@ export class OverriddenLogic extends BaseNode {
     // 需要类型推导的局部变量/返回值需要调整申明顺序
     const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
     const callFunctionAdvanceMap: Map<Return | Variable, CallFunction> = new Map();
-    yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
-      if (
-        el &&
-        // 批量赋值
-        (asserts.isBatchAssignment(el) ||
-          // 赋值
-          (asserts.isAssignment(el) && el.left?.name) ||
-          // 内置函数对集合类型的推导
-          (asserts.isCallFunction(el) && el.derivablecollection?.name))
-      ) {
-        if (el?.getAncestor('SubLogic')) {
-          return;
-        }
-        if (asserts.isAssignment(el)) {
-          const advanceVar = self.variables?.find(
-            (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
-          );
-          if (advanceVar && !advanceMap.get(advanceVar)) {
-            advanceMap.set(advanceVar, el);
-          }
-          const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && el.left?.name === ret.name);
-          if (advanceRn && !advanceMap.get(advanceRn)) {
-            advanceMap.set(advanceRn, el);
-          }
-        } else if (asserts.isCallFunction(el)) {
-          // 需要被推导的集合
-          const expression = el.derivablecollection;
-          // 宽泛意义上的变量（变量+出参）
-          const advanceVar = [...(self.variables || []), ...(self.returns || [])].find((variable) => {
-            return !variable.typeAnnotation && expression?.name === variable.name;
-          });
-          if (advanceVar && !callFunctionAdvanceMap.get(advanceVar)) {
-            callFunctionAdvanceMap.set(advanceVar, el);
-          }
-        } else if (asserts.isBatchAssignment(el)) {
-          yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
-            const leftCode =
-              leftIndex.length === 1
-                ? yield* el.left.expression.toEmbeddedTS(shiftState(state, code, { inline: true }))
-                : yield* el.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
-                    returnOrigin('');
-            const advanceVar = self.variables?.find(
-              (variable) => !variable.typeAnnotation && leftCode === variable.name,
-            );
-            if (advanceVar && !advanceMap.get(advanceVar)) {
-              advanceMap.set(advanceVar, el);
-            }
-            const advanceRn = self.returns?.find((ret) => !ret.typeAnnotation && leftCode === ret.name);
-            if (advanceRn && !advanceMap.get(advanceRn)) {
-              advanceMap.set(advanceRn, el);
-            }
-          });
-        }
-      }
-    });
+    yield* reCollectTyInferCtx(advanceMap, callFunctionAdvanceMap, self);
+
     // 兼容 return 没有类型情况
     if (self.returns.length && self.returns[0].typeAnnotation) {
       code += ': ';
@@ -1778,7 +1726,7 @@ export class OverriddenLogic extends BaseNode {
                 && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
               )
               || (
-                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode)) 
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode))
                 && !(itemNode?.typeAnnotation)
               )
             ) {

package/src/concepts/ProcessElementV2__.ts

@@ -45,6 +45,7 @@ import FlowConditionV2 from './FlowConditionV2__';
 import Logic from './Logic__';
 import BindEvent from './BindEvent__';
 import ApprovalPolicyV2 from './ApprovalPolicyV2__';
+import { varScopeCtx } from '../../../nasl/src/server/semanticData';
 
 /**
  * 流程元素
@@ -1536,6 +1537,9 @@ export class ProcessElementV2 extends BaseNode {
   subLogics: Array<SubLogic> = [];
 
   getSubLogics() {
+    if (varScopeCtx.isFirstScreen) {
+      return;
+    }
     const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
       if (asserts.isSubLogic(node)) {
         return true;

package/src/concepts/ProcessElement__.ts

@@ -43,6 +43,7 @@ import Return from './Return__';
 import Constant from './Constant__';
 import BindAttribute from './BindAttribute__';
 import MultiApprovalPolicy from './MultiApprovalPolicy__';
+import { varScopeCtx } from '../../../nasl/src/server/semanticData';
 
 /**
  * 流程元素
@@ -1733,6 +1734,9 @@ export class ProcessElement extends BaseNode {
     // 只有 AutoTask 才需要在他的节点下找子逻辑
     // 其他直接在 BindEvent 下找
     if (this.type !== 'AutoTask') return [] as SubLogic[];
+    if (varScopeCtx.isFirstScreen) {
+      return;
+    }
     const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
       if (asserts.isSubLogic(node)) {
         return true;

package/src/concepts/ProcessV2__.ts

@@ -28,6 +28,8 @@ import ProcessElementV2 from './ProcessElementV2__';
 import HistoryProcessV2 from './HistoryProcessV2__';
 import ProcessBindV2 from './ProcessBindV2__';
 import BindEvent from './BindEvent__';
+import { varScopeCtx } from '../../../nasl/src/server/semanticData';
+
 /**
  * 流程
  */
@@ -1046,6 +1048,9 @@ export class ProcessV2 extends BaseNode {
   subLogics: Array<SubLogic> = [];
 
   getSubLogics() {
+    if (varScopeCtx.isFirstScreen) {
+      return;
+    }
     const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
       if (asserts.isSubLogic(node)) {
         return true;

package/src/concepts/Process__.ts

@@ -36,6 +36,7 @@ import Param from './Param__';
 import Return from './Return__';
 import Constant from './Constant__';
 import ProcessElement from './ProcessElement__';
+import { varScopeCtx } from '../../../nasl/src/server/semanticData';
 
 /**
  * 流程
@@ -1497,6 +1498,9 @@ export class Process extends BaseNode {
   subLogics: Array<SubLogic> = [];
 
   getSubLogics() {
+    if (varScopeCtx.isFirstScreen)  {
+      return;
+    }
     const subLogics = this.findNaslNodeByBFS((node: BaseNode) => {
       if (asserts.isSubLogic(node)) {
         return true;