@lcap/nasl 3.8.2-beta.9 → 3.8.3-beta.2

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/server/translator.ts

@@ -332,6 +332,11 @@ const TS_RULES: Array<{
     re: /Cannot find name '__UNSUPPORTED__ENTITY__FIELDS__'./,
     result: '可能为实体属性别名，动态条件中仅支持使用变量',
   },
+  {
+    re: /Cannot find name '__UNDEFINED__VARIABLE__(.+?)__'./,
+    result: '所选择的内容 $1 未定义。',
+    transforms: [outOriginalvalue],
+  },
   {
     re: /No value exists in scope for the shorthand property '__(?:IDENTIFIER|LEFT|RIGHT)__'. Either declare one or provide an initializer./,
     result: '用户任务未关联页面',

package/src/templator/block2nasl/jsx2nasl/index.ts

@@ -0,0 +1,11 @@
+import transformExpression2nasl from './transform-expression2nasl';
+import transformTsType2Nasl from './transform-tstype2nasl';
+import transformFunc2Nasl from './transform-func2nasl';
+import transformTSX2Nasl from './transform-tsx2nasl';
+
+export {
+  transformExpression2nasl,
+  transformTsType2Nasl,
+  transformFunc2Nasl,
+  transformTSX2Nasl,
+};