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

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;

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/OqlQueryComponent__.ts

@@ -14,9 +14,6 @@ import type StructureProperty from './StructureProperty__';
 import type Structure from './Structure__';
 import type Identifier from './Identifier__';
 import type MemberExpression from './MemberExpression__';
-import type { Entity } from './Entity__';
-import type { EntityProperty } from './EntityProperty__';
-import { naslOQLCacheStore } from '../utils/language-cache/nasl';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -32,6 +29,7 @@ import * as asserts from './utils/asserts';
 
 import TypeAnnotation from './TypeAnnotation__';
 import LogicItem from './LogicItem__';
+import api from '../service/logic/api';
 
 /**
  * SQL 查询
@@ -278,77 +276,6 @@ export class OqlQueryComponent extends LogicItem {
     return `sql"${code}"`;
   }
 
-  // 从服务端获取 SQL -> TS 的翻译和 sourceMap
-  async requestEmbeddedTS(): Promise<any> {
-    const { http, logger } = this.rootNode.naslServer;
-
-    if (this.code) {
-      let dataSourceNasl = this.app.findNodeByCompleteName(this.dataSource)?.toJSON();
-      if (dataSourceNasl) {
-        dataSourceNasl = {
-          concept: 'DataSource',
-          entities: (dataSourceNasl.entities = dataSourceNasl.entities?.map((entity: Entity) => {
-            return {
-              name: entity.name,
-              concept: entity.concept,
-              tableName: entity.tableName,
-              properties: entity.properties?.map((prop: EntityProperty) => {
-                return {
-                  name: prop.name,
-                  concept: prop.concept,
-                  columnName: prop.columnName,
-                };
-              }),
-            };
-          })),
-        };
-      }
-
-      const query = async () => {
-        const params = {
-          appId: 'myAppId',
-          oqlIdentifier: 'myoqlIdentifier',
-          dataSourceName: this.dataSource,
-          oql: this.code,
-          ideVersion: this.app.ideVersion,
-          dataSourceNasl,
-          typeScriptStartLine: 1,
-          typeScriptStartLineColumn: 1,
-        };
-        const key = JSON.stringify(params);
-        let res = null;
-        let canUseCache = false;
-        try {
-          res = await naslOQLCacheStore.getItem(key);
-          canUseCache = true;
-        } catch (error) {}
-        if (res !== null) {
-          return res;
-        }
-        return http
-          .post('/api/v1/querydebug/generate/typescript', params)
-          .then(async ({ data }) => {
-            if (canUseCache) {
-              try {
-                await naslOQLCacheStore.setItem(key, data);
-              } catch (error) {}
-            }
-            return data;
-          });
-      };
-
-      return query()
-        .then((data: any) => {
-          this.codeSourceMap = data.result ?? { typescript: '', lexicalErrorCode: 1001 };
-        })
-        .catch((err) => {
-          logger.error('Oql 请求失败', err.toString());
-          this.codeSourceMap = { typescript: '', lexicalErrorCode: 1001 };
-        });
-    }
-    this.codeSourceMap = { typescript: '', lexicalErrorCode: 1001 };
-  }
-
   /**
    * 获取添加时的默认选项
    * @returns

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