@lcap/nasl 3.8.3-beta.4 → 3.8.3-beta.5

package/src/concepts/App__.ts

@@ -3839,23 +3839,24 @@ export class App extends BaseNode {
   deleteCompose(path: string[]) {
     if (!Array.isArray(path)) return;
     let compose = this.composeCache;
-
-    const delNodes = (_compose: composeCacheType) => {
+    const delNodes = (_compose: composeCacheType, key: string) => {
       if (_compose?.nodes) {
         for (const key in _compose) {
-          if (key !== 'nodes') {
-            delNodes(_compose[key]);
+          // 只有form和table层级触发删除
+          if (key !== 'nodes' && key !== 'saveModalForm') {
+            delNodes(_compose[key], key);
           }
         }
         const arr = [..._compose.nodes] || [];
-        const triggerNode: BaseNode[] = []; // 触点放在最后删
-        arr.forEach((node) => {
-          if (node.name === path?.[0]) {
-            triggerNode.push(node);
-          } else {
-            node && node.delete();
-          }
-        });
+        // table内的saveModalForm.nodes也在table层级一起删除，避免先删父后删子的情况
+        if (_compose.hasOwnProperty('saveModalForm')) {
+          arr.push(..._compose.saveModalForm.nodes);
+        }
+        // 按照路径长度，粗粒度处理好父子关系后，再删除节点
+        const triggerNode = arr
+          .map((item, index) => ({ nodePath: item?.nodePath, index }))
+          .sort((a, b) => b.nodePath.length - a.nodePath.length)
+          .map((item) => arr[item.index]);
 
         triggerNode.forEach((node) => {
           node && node.delete();
@@ -3867,10 +3868,13 @@ export class App extends BaseNode {
 
     this.emit('collect:start', {
       actionMsg: '删除同一分组节点',
+      extra: {
+        isCustomDesigner: true,
+      },
     });
     path.forEach((key, index) => {
       if (index === path.length - 1) {
-        delNodes(compose?.[key]);
+        delNodes(compose?.[key], key);
       } else {
         compose = compose[key];
       }

package/src/concepts/AuthLogicForCallInterface__.ts

@@ -42,6 +42,7 @@ import * as asserts from './utils/asserts';
 
 import Param from './Param__';
 import AuthLogic from './AuthLogic__';
+import { reCollectTyInferCtx } from '../server/semanticData';
 
 /**
  * 调用接口的鉴权逻辑
@@ -352,61 +353,7 @@ export class AuthLogicForCallInterface extends AuthLogic {
     // 需要类型推导的局部变量/返回值需要调整申明顺序
     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);
     code += '{\n';
     // 用于虚拟节点的查找引用
     if (Array.isArray(self.virtualParams)) {
@@ -551,7 +498,7 @@ export class AuthLogicForCallInterface extends AuthLogic {
                 && itemNode.typeAnnotation?.typeKind === 'anonymousStructure'
               )
               || (
-                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode)) 
+                (asserts.isNewList(itemNode) || asserts.isNewMap(itemNode))
                 && !(itemNode?.typeAnnotation)
               )
             ) {

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 '../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 '../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/CallLogic__.ts

@@ -1667,7 +1667,9 @@ export class CallLogic extends LogicItem {
     return tag;
   }
 
-  getCallNodeUsingCache(frontNdCache: Map<string, Logic>, serverNdCache: Map<string, Logic>, processNdCache: Map<string, Logic>): ['front' | 'server' | 'process', Logic | undefined] {
+  getCallNodeUsingCache(
+    frontNdCache : Map<string, Logic>, serverNdCache : Map<string, Logic>,
+    processNdCache : Map<string, Logic>): ['front' | 'server' | 'process', Logic | undefined] {
     const cwKey = this.calleewholeKey;
     if (serverNdCache.get(cwKey)) {
       return ['server', serverNdCache.get(cwKey)];
@@ -1681,18 +1683,20 @@ export class CallLogic extends LogicItem {
 
     let node;
     // 如果是页面局部逻辑
-    if (!this.calleeNamespace && this.calleeName && this.view) {
-      node = this.view.logics.find((l) => l.name === this.calleeName);
+    if (!this.calleeNamespace && this.calleeName && this.likeComponent) {
+      node = this.likeComponent.logics.find((l) => l.name === this.calleeName);
     } else if (this.calleeNamespace?.startsWith('nasl.')) {
       // 如果是页面组件
       node = getNaslNodeByNodeCallee(this.calleeNamespace, this.calleeName);
     } else if (this.calleeNamespace?.startsWith('elements.')) {
       // 查找组件的逻辑，用于展示默认值
       const elementsLogic = (this.app as any)?.naslServer?.elementsLogic || {};
+
       let tag = this.getElementTagByLogic();
       // tag转换为首字母大写，驼峰
       tag = tag.replace(/^\S/, (s) => s.toUpperCase())
-        .replace(/-(\w)/g, (all, letter) => letter.toUpperCase());
+              .replace(/-(\w)/g, (all, letter) => letter.toUpperCase());
+
       const logics = elementsLogic[`${tag}`] || [];
       node = logics.find((l: any) => l.name === this.calleeName);
     } else {

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 '../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 '../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;