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

package/src/server/naslServer.ts

@@ -124,6 +124,8 @@ import { withQueueExecute } from '../decorators';
 import { getNodeByNodeCallee } from '../automate/engine/utils';
 import { isApp, isConnection, isConnector, isMsgTriggerEvent, isProcess, isProcessV2, isStrictLogic } from '../concepts/utils/asserts';
 
+import { collectAllSemanticCtx, clearSemanticData, printSemanticDataInfo } from './semanticData';
+
 const EmbeddedTSFileLineMap: { [name: string]: number } = {
   Entity: 3,
 };
@@ -649,6 +651,10 @@ class NaslServer {
 
   async openApp(app: App, performance = false, needRegisterCommand = true) {
     this.logger.time('生成 TS 文件');
+    this.logger.time('简单语义分析');
+    await utils.runGeneratorSync(collectAllSemanticCtx(app));
+    this.logger.timeEnd('简单语义分析');
+    // printSemanticDataInfo();
     invokeCommand('naslServer:startWork');
 
     app.naslServer = this;
@@ -677,6 +683,7 @@ class NaslServer {
         callback();
       });
     }
+    clearSemanticData();
     this.logger.timeEnd('生成 TS 文件');
 
     function* getAllTsFiles() {
@@ -1121,7 +1128,9 @@ class NaslServer {
         return;
       }
 
-      const { node } = record;
+      let { node } = record;
+      // @ts-ignore
+      node = node.__v_raw || node; // 暂时先这样提速
 
       // 先获取原来的节点先清除一下之前有异常的节点，下面重新赋值
       const oldRecord = self.diagnosticManager.getRecord?.(record.id);
@@ -1815,6 +1824,8 @@ class NaslServer {
    */
   private *_attachDiagnosticsWithGenerator(fileNode: BaseNode) {
     // 每次诊断前先清空这个Set
+    // @ts-ignore
+    fileNode = fileNode.__v_raw || fileNode; // 暂时先这样提速
     this.logicSetWithComponentLogic = new Set<string>();
 
     const self = this;
@@ -3197,11 +3208,15 @@ class NaslServer {
     fileNode: FileNode
   ): Generator<void, MinRange> {
     let minRange: MinRange;
+    // @ts-ignore
+    fileNode = fileNode.__v_raw || fileNode; // 暂时先这样提速
     const { sourceMap } = fileNode;
     // 是否找到了行内准确的，是的话，就不走多行的
     let haveLineNode = false;
 
-    for (const [node, item] of sourceMap.entries()) {
+    for (let [node, item] of sourceMap.entries()) {
+      // @ts-ignore
+      node = node.__v_raw || node;  // 暂时先这样提速
       /**
        * 当前内容的开始行 <= 诊断开始的行 &&
        * 当前内容的结束行 >= 诊断结束的行
@@ -4663,6 +4678,7 @@ class NaslServer {
       }
       if (
         ![
+
           'Identifier',
           'BinaryExpression',
           'CallLogic',
@@ -4775,8 +4791,10 @@ class NaslServer {
         }
       }
     });
+
     yield* utils.wrapIteratorToGenerator(types.entries(), ([node, value]) => {
       try {
+
         // 因为node可能是经过处理的TypeAnnotation
         node.__isCorrectTypeAnnotation = true;
         if (value) {
@@ -5492,6 +5510,7 @@ class NaslServer {
    */
   async handleRename(fileNode: BaseNode, targetNode: BaseNode, result: utils.EmbeddedTSFileResult, oldFilePath?: string) {
     // rename 场景
+
     const outputFiles = [{ file: result.filePath, fileContent: result.code }];
     // 如果是要修改顶级文件名
     // file节点和当前改得是同一节点
@@ -5798,6 +5817,7 @@ class NaslServer {
 
   changeFileNext() {
     if (!this.singleFileChangeIng) {
+      // SHIFT IS O(n) AND SLOW
       const item = this.changeStackList.shift();
       this.receiveHandleChange(item)
         .catch((err) => {

package/src/server/semanticData.ts

@@ -0,0 +1,447 @@
+import { App, Identifier, MemberExpression, View, ViewElement, BaseNode, Return, Variable,
+  Assignment, BatchAssignment, CallFunction, AuthLogicForCallInterface, BusinessComponent, BusinessLogic,
+  Logic, OverriddenLogic, SubLogic,
+  Process,
+  ProcessV2,
+  ProcessElement,
+  ProcessElementV2,
+} from '..';
+
+import { SyntaxNode } from '../concepts/utils/types';
+
+import { createCompilerState, shiftState } from '../translator';
+import { runGeneratorAsync, runGeneratorSync, wrapForEachToGenerator, returnOrigin } from '../utils';
+
+type VarScopeCtx = {
+  // 优化首屏 getAncestor 热点代码
+  app: App;
+  isFirstScreen: boolean;
+  frontendGlobalVars: Set<string>;
+  varInViewOrComponent: Set<string>;
+  logicInViewOrComponent: Set<string>;
+  idToView: Map<Identifier, View>;
+  ctxViewElement: Array<ViewElement>;
+  ctxView: Array<View>;
+  isInViewOrComponent: boolean;
+  memExprToViewElem: Map<MemberExpression, ViewElement>;
+}
+
+type TyInferCtx = {
+    // 优化首屏 类型推导，变量提升
+    inferViaAsgnMap: Map<Return | Variable , Assignment | BatchAssignment | CallFunction>,
+    inferViaFnCallMap: Map<Return | Variable , CallFunction>,
+    scope: Array<AuthLogicForCallInterface | BusinessComponent | BusinessLogic | Logic | OverriddenLogic | SubLogic | View>,
+    // key 用 name 是不精确的，应该用地址。 暂时用 name，后面比较的时候简单点，暂时应该没 bug
+    // 全局变量暂不支持推导
+    capturedVars: Map<string, Variable | Return>,
+}
+
+type SubLogicCtx = {
+  // naslNodesCount: number;
+  ctx: Logic | Process | ProcessV2 | ProcessElement | ProcessElementV2 | null;
+  // 我也不知道为啥 view 这么特殊
+  viewSubLogics: Set<SubLogic>;
+}
+
+// 前端全局变量很少，一般就十个以内，所以 map 大小可以忽略不计
+export const varScopeCtx : VarScopeCtx = {
+  app: null,
+  isFirstScreen: false,
+  frontendGlobalVars: new Set<string>(),
+  // Collect all params, (local) variables, and logic names under business component
+  // Note that within a business component, one can only refer to the above variables, and cannot refer to
+  // frontend global variables and any other variables under Views; therefore, checking the Name already suffices.
+  // 收集业务组件下的所有参数、（局部）变量和逻辑名称，请注意，在业务组件中，只能引用上述变量，
+  // 而不能引用前端全局变量和其他任何 “视图 ”下的变量；因此，检查 “Name” 已经足够了。
+  varInViewOrComponent: new Set<string>(),
+
+  logicInViewOrComponent: new Set<string>(),
+
+  // Collect all params, (local) variables, and logic names under views
+  // Actually, frontendGlobalVars U idInView U idInComponent should be the complete set of accessible variables
+  // 事实上，frontendGlobalVars 并上 idInView 并上 idInComponent 应该是前端所有能访问到的变量（名的集合）
+
+  // 赫基 27w 应用，前端 View 下有 2000 个变量名字；56176 个变量引用，内存占用约 1M。
+  idToView: new Map<Identifier, View>(),
+
+  // 路径上的 ViewElement 节点
+  ctxViewElement: [],
+
+  // 路径上的 View 节点
+  ctxView: [],
+
+  isInViewOrComponent: false,
+
+  memExprToViewElem: new Map<MemberExpression, ViewElement>(),
+};
+
+export const tyInferCtx : TyInferCtx = {
+  inferViaAsgnMap: new Map(),
+  inferViaFnCallMap: new Map(),
+  scope: [],
+  capturedVars: new Map(),
+}
+
+export const subLogicCtx : SubLogicCtx = {
+  // naslNodesCount: 0,
+  ctx: null, // 当前逻辑
+  viewSubLogics : new Set<SubLogic>(), // 隶属于 view 的 SubLogic，需要排除掉隶属于 Logic 的 SubLogic。
+}
+
+const last = <T>(arr: Array<T>) => arr[arr.length - 1];
+
+
+export function *collectAllSemanticCtx(app: App) {
+  varScopeCtx.app = app;
+  varScopeCtx.isFirstScreen = true;
+  const tasks = [
+    // collectFrontendVariablesTask, 这样不值得，能快一点还是快一点吧，
+    collectVarInViewOrComponentCtxTask,
+    collectLogicInViewOrComponentTask,
+    // collectMemExprToViewElemCtxTask, // 因为 $ce 的原因，暂时用不了
+    collectIdToViewCtxTask,
+    collectSubLogicCtxTask,
+    collectTyInferCtxTask
+  ];
+
+  const cleanups = [
+    collectVarInViewOrComponentCtxCleanup,
+    // collectLogicInViewOrComponentCleanup,
+    // collectMemExprToViewElemCtxCleanup, // 因为 $ce 的原因，暂时用不了
+    collectIdToViewCtxCleanup,
+    collectSubLogicCtxCleanup,
+    collectTyInferCtxCleanup
+  ];
+
+  runGeneratorSync(collectFrontendVariablesTask(app));
+  runGeneratorSync(app.traverseStrictChildrenDoMultiTasks(tasks, cleanups));
+}
+
+
+function *collectFrontendVariablesTask(app: App) {
+  app.frontendTypes.forEach(ft => {
+    ft.frontends.forEach(f => {
+      f.variables.forEach(v => {
+        varScopeCtx.frontendGlobalVars.add(v.name);
+      });
+    });
+  })
+}
+
+function *collectVarInViewOrComponentCtxTask(nd: SyntaxNode) {
+  switch (nd.concept) {
+    case 'Variable': /* FALL THROUGH */
+    case 'Param': /* FALL THROUGH */
+    case 'Return': {
+      if (varScopeCtx.isInViewOrComponent) {
+        varScopeCtx.varInViewOrComponent.add(nd.name);
+      }
+      break;
+    }
+    case 'View': /* FALL THROUGH */
+    case 'BusinessComponent': varScopeCtx.isInViewOrComponent = true; break;
+    default: break;
+  }
+}
+
+function *collectVarInViewOrComponentCtxCleanup(nd: SyntaxNode) {
+  if (nd.concept === 'View' || nd.concept === 'BusinessComponent') {
+    varScopeCtx.isInViewOrComponent = false;
+  }
+}
+
+
+// component-like：业务组件下的变量引用
+function *collectLogicInViewOrComponentTask(nd: SyntaxNode) {
+  if (nd.concept === 'Logic' || nd.concept === 'BusinessComponent') {
+    if (varScopeCtx.isInViewOrComponent) {
+      varScopeCtx.logicInViewOrComponent.add(nd.name);
+    }
+  }
+}
+// collectLogicInViewOrComponentCleanup 的事情被 collectVarInViewOrComponentCtxPost 做了
+
+
+function *collectMemExprToViewElemCtxTask(nd: SyntaxNode) {
+  // view 下的 identifier 的 getAncestor 必定有 view
+  switch (nd.concept) {
+    case 'ViewElement': {
+      varScopeCtx.ctxViewElement.push(nd as ViewElement);
+      break;
+    }
+    case 'MemberExpression': {
+      if (varScopeCtx.ctxViewElement) {
+        varScopeCtx.memExprToViewElem.set(nd as MemberExpression, last(varScopeCtx.ctxViewElement));
+      }
+      break;
+    }
+    default: break;
+  }
+}
+
+function *collectMemExprToViewElemCtxCleanup(nd: SyntaxNode) {
+  if (nd.concept === 'ViewElement') {
+    varScopeCtx.ctxViewElement.pop();
+  }
+}
+
+
+function *collectIdToViewCtxTask(nd: SyntaxNode) {
+  // view 下的 identifier 的 getAncestor 必定有 view
+  switch (nd.concept) {
+    case 'View': varScopeCtx.ctxView.push(nd); break;
+    case 'Identifier': {
+      if (varScopeCtx.ctxView.length > 0) {
+        varScopeCtx.idToView.set(nd as Identifier, last(varScopeCtx.ctxView));
+      }
+      break;
+    }
+    default: break;
+  }
+}
+
+function *collectIdToViewCtxCleanup(nd: SyntaxNode) {
+  switch (nd.concept) {
+    case 'View': varScopeCtx.ctxView.pop(); break;
+    default: break;
+  }
+}
+
+
+function *collectSubLogicCtxTask(nd : SyntaxNode) {
+    switch (nd.concept) {
+      case 'Logic': /* FALL THROUGH */
+      /* 流程支持子逻辑 */
+      /* 流程变量不支持类型推导 */
+      case 'Process': /* FALL THROUGH */
+      case 'ProcessV2': /* FALL THROUGH */
+      case 'ProcessElement': /* FALL THROUGH */
+      case 'ProcessElementV2': /* FALL THROUGH */
+      case 'BusinessLogic': subLogicCtx.ctx = nd; break;
+      case 'SubLogic': {
+        // 收集子逻辑
+        if (subLogicCtx.ctx) {
+          subLogicCtx.ctx.subLogics.push(nd as SubLogic);
+          // console.log('逻辑或流程的子逻辑：', subLogicCtx.ctx)
+        } else {
+          subLogicCtx.viewSubLogics.add(nd as SubLogic);
+        }
+        break;
+      }
+      default: break;
+    }
+}
+
+function *collectSubLogicCtxCleanup(nd : SyntaxNode) {
+  switch (nd.concept) {
+    /* 流程支持子逻辑 */
+    /* 流程变量不支持类型推导 */
+    case 'Logic': /* FALL THROUGH */
+    case 'Process': /* FALL THROUGH */
+    case 'ProcessV2': /* FALL THROUGH */
+    case 'ProcessElement': /* FALL THROUGH */
+    case 'ProcessElementV2': subLogicCtx.ctx = null; break;
+    // 可能是有人忘了给业务组件加 subLogics？
+    case 'View': {
+      subLogicCtx.viewSubLogics.forEach(sl => { nd.subLogics.push(sl); });
+      // console.log('View 的子逻辑：', nd.subLogics)
+      subLogicCtx.viewSubLogics.clear();
+      break;
+    }
+    default: break;
+  }
+}
+
+
+const addVars = (nd : Array<Variable> | Array<Return>, s : Map<string, Variable | Return>) => {
+  nd.forEach(v => {
+    if (!v.typeAnnotation) {
+      s.set(v.name, v);
+    }
+  })
+}
+
+const removeVars = (nd : Array<Variable> | Array<Return>, s : Map<string, Variable | Return>) => {
+  nd.forEach(v => s.delete(v.name))
+}
+
+
+// OQL 批量优化优化完成前请勿移除
+// const oqlSet = new Set<string>();
+
+function *collectTyInferCtxTask(nd : SyntaxNode) {
+  // ++subLogicCtx.naslNodesCount;
+  // if (nd.concept === 'OqlQueryComponent') {
+  //   oqlSet.add(nd.code);
+  // }
+  switch (nd.concept) {
+    case 'Logic': /* FALL THROUGH */
+    case 'AuthLogicForCallInterface': /* FALL THROUGH */
+    case 'BusinessLogic': /* FALL THROUGH */
+    case 'OverriddenLogic': /* FALL THROUGH */
+    case 'SubLogic': {
+      // 全局变量不支持类型推导；逻辑的变量也不支持跨子逻辑推导
+      // addVars(nd.variables, tyInferCtx.capturedVars);
+      // addVars(nd.returns, tyInferCtx.capturedVars);
+      tyInferCtx.scope.push(nd);
+      break;
+    }
+    case 'View': /* FALL THROUGH */
+    case 'BusinessComponent': {
+      addVars(nd.variables, tyInferCtx.capturedVars);
+      tyInferCtx.scope.push(nd);
+      break;
+    }
+    default: {
+      runGeneratorAsync(
+        collectAsgn(tyInferCtx.inferViaAsgnMap, tyInferCtx.inferViaFnCallMap, nd));
+      break;
+    }
+  }
+}
+
+function *collectTyInferCtxCleanup(nd : SyntaxNode) {
+  switch (nd.concept) {
+    case 'Logic': /* FALL THROUGH */
+    case 'AuthLogicForCallInterface': /* FALL THROUGH */
+    case 'BusinessLogic': /* FALL THROUGH */
+    case 'OverriddenLogic': /* FALL THROUGH */
+    case 'SubLogic': {
+      // removeVars(nd.variables, tyInferCtx.capturedVars);
+      // removeVars(nd.returns, tyInferCtx.capturedVars);
+      tyInferCtx.scope.pop();
+      break;
+    }
+
+    case 'View': /* FALL THROUGH */
+    case 'BusinessComponent': {
+      removeVars(nd.variables, tyInferCtx.capturedVars);
+      tyInferCtx.scope.pop();
+      break;
+    }
+    default: break;
+  }
+}
+
+
+type LogicContainer = AuthLogicForCallInterface | BusinessComponent | BusinessLogic | Logic | OverriddenLogic | SubLogic | View;
+
+export function *reCollectTyInferCtx(
+    inferViaAsgn: Map<Return | Variable, Assignment | BatchAssignment | CallFunction>,
+    inferViaFnCall: Map<Return | Variable, CallFunction>,
+    self: LogicContainer) {
+
+  // No (types of) variables to be inferred
+  // @ts-ignore
+  const preTest = self.variables?.some((v : Variable) => !v.typeAnnotation) || self.returns?.some((v : Variable) => !v.typeAnnotation)
+  if (!preTest) {
+    return;
+  }
+
+  // 非首次则清空脏 map，重新收集所需上下文
+  if (!varScopeCtx.isFirstScreen) {
+    tyInferCtx.inferViaAsgnMap.clear();
+    tyInferCtx.inferViaFnCallMap.clear();
+    yield* self.traverseChildrenGenerator(collectTyInferCtxTask);
+  }
+
+  self.variables.forEach((locVar : Variable) => {
+    if (tyInferCtx.inferViaAsgnMap.has(locVar)){
+      inferViaAsgn.set(locVar, tyInferCtx.inferViaAsgnMap.get(locVar))
+    } else if (tyInferCtx.inferViaFnCallMap.has(locVar)){
+      inferViaFnCall.set(locVar, tyInferCtx.inferViaFnCallMap.get(locVar))
+    }
+  });
+  // @ts-ignore
+  self.returns?.forEach((locRet : Return) => {
+    if (tyInferCtx.inferViaAsgnMap.has(locRet)){
+      inferViaAsgn.set(locRet, tyInferCtx.inferViaAsgnMap.get(locRet))
+    } else if (tyInferCtx.inferViaFnCallMap.has(locRet)){
+      inferViaFnCall.set(locRet, tyInferCtx.inferViaFnCallMap.get(locRet))
+    }
+  });
+}
+
+function *collectAsgn(
+  inferViaAsgnMap: Map<Return | Variable, Assignment | BatchAssignment | CallFunction>,
+  inferViaBuiltinFnMap: Map<Return | Variable, CallFunction>,
+  nd: SyntaxNode) {
+  const self = last(tyInferCtx.scope); // 可能是 undefined
+  if (!nd || !self) {
+    return;
+  }
+
+  if (nd.concept === 'Assignment' && nd.left?.name) {
+    if (!self) {
+      console.log('nd', nd)
+    }
+    const hoistVar = self.variables?.find(v => nd.left?.name === v.name && !v.typeAnnotation)
+        // View 和 BusinessComponent 没有 returns
+        // @ts-ignore
+        ?? self.returns?.find(ret => nd.left?.name === ret.name && !ret.typeAnnotation)
+        ?? tyInferCtx.capturedVars.get(nd.left.name);
+    if (hoistVar && !inferViaAsgnMap.has(hoistVar)) {
+      inferViaAsgnMap.set(hoistVar, nd);
+    }
+  } else if (nd.concept === 'BatchAssignment') {
+    yield* wrapForEachToGenerator(nd.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
+      const leftCode =
+        leftIndex.length === 1
+          ? yield* nd.left.expression.toEmbeddedTS(shiftState(createCompilerState(), '', { inline: true }))
+          : yield* nd.left.members[leftIndex[1]]?.toEmbeddedTS(shiftState(createCompilerState(), '', { inline: true })) ??
+            returnOrigin('');
+      const hoistVar = self.variables?.find((v : Variable) => leftCode === v.name && !v.typeAnnotation)
+        // View 和 BusinessComponent 没有 returns
+        // @ts-ignore
+        ?? self.returns?.find(ret => leftCode === ret.name && !ret.typeAnnotation)
+        ?? tyInferCtx.capturedVars.get(leftCode);
+      if (hoistVar && !inferViaAsgnMap.has(hoistVar)) {
+        inferViaAsgnMap.set(hoistVar, nd);
+      }
+    });
+  } else if (nd.concept === 'CallFunction' && nd.derivableCollection?.name) {
+    // 需要被推导的集合
+    const expr = nd.derivableCollection;
+    // 宽泛意义上的变量（变量+出参），View 和 BusinessComponent 没有 returns
+    const hoistVar = self.variables.find((v) => expr?.name === v.name && !v.typeAnnotation)
+      // @ts-ignore
+      ?? self.returns?.find(ret => expr?.name === ret.name && !ret.typeAnnotation)
+      ?? tyInferCtx.capturedVars.get(expr.name);
+    if (hoistVar && !inferViaBuiltinFnMap.has(hoistVar)) {
+      inferViaBuiltinFnMap.set(hoistVar, nd);
+    }
+  }
+}
+
+export const clearSemanticData = () => {
+  varScopeCtx.isFirstScreen = false;
+  varScopeCtx.frontendGlobalVars.clear();
+  varScopeCtx.varInViewOrComponent.clear();
+  varScopeCtx.logicInViewOrComponent.clear();
+  varScopeCtx.idToView.clear();
+  varScopeCtx.ctxViewElement = [];
+  varScopeCtx.memExprToViewElem.clear();
+  tyInferCtx.inferViaAsgnMap.clear();
+  tyInferCtx.inferViaFnCallMap.clear();
+  tyInferCtx.scope = [];
+  tyInferCtx.capturedVars.clear();
+  subLogicCtx.viewSubLogics.clear();
+  subLogicCtx.ctx = null;
+}
+
+export function printSemanticDataInfo() {
+  console.log('frontendGlobalVars', varScopeCtx.frontendGlobalVars)
+  console.log('varInViewOrComponent', varScopeCtx.varInViewOrComponent)
+  console.log('logicInViewOrComponent', varScopeCtx.logicInViewOrComponent)
+  console.log('idToView', varScopeCtx.idToView)
+  console.log('memExprToViewElem', varScopeCtx.memExprToViewElem)
+  console.log('inferViaAsgnMap', tyInferCtx.inferViaAsgnMap)
+  console.log('inferViaFnCallMap', tyInferCtx.inferViaFnCallMap)
+  // console.log(oqlSet)
+  // console.log('capturedVars', tyInferCtx.capturedVars)
+  // console.log('viewSubLogics', subLogicCtx.viewSubLogics)
+  // console.log('naslNodesCount', subLogicCtx.naslNodesCount)
+  // console.log('ctx', subLogicCtx.ctx)
+  // console.log('scope', tyInferCtx.scope)
+  // console.log('isFirstScreen', varScopeCtx.isFirstScreen)
+}

package/src/templator/block2nasl/viewMergeBlock.ts

@@ -37,7 +37,8 @@ export function viewMergeBlock({
   const naslCode = tryTransformBlock2Nasl(code);
   const blockView = naslCode.view;
   // vue2需要对tag进行转换 kebab-case
-  if(((((view as any)?.parentNode as Frontend))?.parentNode as FrontendType)?.frameworkKind  === 'vue2') {
+  const frontendType = (view as any)?.getAncestor('FrontendType');
+  if((frontendType as any)?.frameworkKind  === 'vue2') {
     traverse(({ node }) => {
       if (node.concept === 'ViewElement') {
         node.tag = Camel2kebab(node.tag);

package/src/translator/utils.ts

@@ -314,4 +314,4 @@ export function createIdentifierCode(name: string) {
 
 export function textualNamespace(name: string) {
   return name.replace(/\./g, '::');
-}
+}