Lines Matching refs:node
171 export function processComponentBuild(node: ts.MethodDeclaration,
180 if (node.body && node.body.statements && node.body.statements.length &&
181 validateRootNode(node, log)) {
182 newNode = ts.factory.updateMethodDeclaration(node, node.decorators, node.modifiers,
183 node.asteriskToken, renderNode, node.questionToken, node.typeParameters, node.parameters,
184 node.type, processComponentBlock(node.body, false, log));
186 newNode = ts.factory.updateMethodDeclaration(node, node.decorators, node.modifiers,
187 node.asteriskToken, renderNode, node.questionToken, node.typeParameters, node.parameters,
188 node.type, node.body);
193 export function processComponentBlock(node: ts.Block, isLazy: boolean, log: LogInfo[],
197 …processComponentChild(node, newStatements, log, {isAcceleratePreview: false, line: 0, column: 0, f…
221 return ts.factory.updateBlock(node, newStatements);
224 function validateRootNode(node: ts.MethodDeclaration, log: LogInfo[]): boolean {
226 if (node.body.statements.length === 1) {
227 const statement: ts.Statement = node.body.statements[0];
238 pos: node.body.statements.pos
244 function validateFirstNode(node: ts.Statement): boolean {
247 if (isEntryComponent && !validateContainerComponent(node)) {
253 function validateContainerComponent(node: ts.Statement): boolean {
254 if (ts.isExpressionStatement(node) && node.expression &&
255 (ts.isEtsComponentExpression(node.expression) || ts.isCallExpression(node.expression))) {
256 const nameResult: NameResult = { name: null, node: null, arguments: [] }; constant
257 validateEtsComponentNode(node.expression, nameResult);
258 if (nameResult.name && checkContainer(nameResult.name, nameResult.node)) {
282 node?: ts.Node
285 function validateEtsComponentNode(node: ts.CallExpression | ts.EtsComponentExpression, result?: Nam…
286 let childNode: ts.Node = node;
295 result.node = childNode;
306 export function processComponentChild(node: ts.Block | ts.SourceFile, newStatements: ts.Statement[],
318 …sourceNode = ts.createSourceFile('', node.getText(), ts.ScriptTarget.Latest, true, ts.ScriptKind.E…
320 if (node.statements.length) {
323 node.statements.forEach((item) => {
414 export function transferBuilderCall(node: ts.ExpressionStatement, name: string,
416 if (node.expression && ts.isCallExpression(node.expression) && node.expression.arguments &&
417 …node.expression.arguments.length === 1 && ts.isObjectLiteralExpression(node.expression.arguments[0…
421 node.expression.expression,
433 traverseBuilderParams(node.expression.arguments[0], isBuilder)
441 node.expression.expression,
448 node.expression.arguments
453 function traverseBuilderParams(node: ts.ObjectLiteralExpression,
456 if (node.properties && node.properties.length) {
457 node.properties.forEach(property => {
527 function addInnerBuilderParameter(node: ts.ExpressionStatement,
529 if (node.expression && ts.isCallExpression(node.expression) && node.expression.arguments) {
530 …node.expression.arguments.push(isGlobalBuilder ? parentConditionalExpression() : ts.factory.create…
531 return ts.factory.createExpressionStatement(ts.factory.updateCallExpression(node.expression,
532 node.expression.expression, node.expression.typeArguments, node.expression.arguments));
534 return node;
538 function processExpressionStatementChange(node: ts.ExpressionStatement, nextNode: ts.Block,
542 if (node.expression.expression && ts.isIdentifier(node.expression.expression)) {
543 name = node.expression.expression.escapedText.toString();
547 return processBlockToExpression(node, nextNode, log, name);
553 pos: node.getStart()
559 function processBlockToExpression(node: ts.ExpressionStatement, nextNode: ts.Block,
568 let argumentsArray: ts.ObjectLiteralExpression[] = node.expression.arguments;
574 node.expression.arguments[0].properties.concat([newPropertyAssignment]), true)];
578 node.expression, node.expression.expression, node.expression.expression.typeArguments,
581 node.expression.expression.parent = callNode;
583 callNode.parent = node.expression.parent;
584 node = ts.factory.updateExpressionStatement(node, callNode);
585 return node;
592 function parseEtsComponentExpression(node: ts.ExpressionStatement): EtsComponentResult {
595 let temp: any = node.expression;
610 function processInnerComponent(node: ts.ExpressionStatement, innerCompStatements: ts.Statement[],
614 const res: CreateResult = createComponent(node, COMPONENT_CREATE_FUNCTION);
617 validateEtsComponentNode(node.expression as ts.EtsComponentExpression, nameResult);
619 processItemComponent(node, nameResult, innerCompStatements, log, isGlobalBuilder, idName);
621 processTabAndNav(node, innerCompStatements, nameResult, log, isGlobalBuilder, idName);
623 …processNormalComponent(node, nameResult, innerCompStatements, log, parent, isBuilder, isGlobalBuil…
628 function processNormalComponent(node: ts.ExpressionStatement, nameResult: NameResult,
633 const res: CreateResult = createComponent(node, COMPONENT_CREATE_FUNCTION);
635 processDebug(node, nameResult, newStatements);
636 const etsComponentResult: EtsComponentResult = parseEtsComponentExpression(node);
646 newStatements.splice(-2, 1, createComponent(node, COMPONENT_CREATE_CHILD_FUNCTION).newNode);
648 newStatements.splice(-1, 1, createComponent(node, COMPONENT_CREATE_CHILD_FUNCTION).newNode);
652 … bindComponentAttr(node, res.identifierNode, newStatements, log, true, false, immutableStatements);
654 processInnerCompStatements(innerCompStatements, newStatements, node, isGlobalBuilder,
659 … bindComponentAttr(node, res.identifierNode, newStatements, log, true, false, immutableStatements);
660 processInnerCompStatements(innerCompStatements, newStatements, node, isGlobalBuilder,
664 innerCompStatements.push(createComponent(node, COMPONENT_POP_FUNCTION).newNode);
693 function processDebug(node: ts.Statement, nameResult: NameResult, newStatements: ts.Statement[],
701 posOfNode = sourceNode.getLineAndCharacterOfPosition(getRealNodePos(node) - 22);
708 posOfNode = transformLog.sourceFile.getLineAndCharacterOfPosition(getRealNodePos(node));
731 …newStatements: ts.Statement[], node: ts.Statement, isGlobalBuilder: boolean, isTransition: boolean,
736 innerCompStatements.push(createComponentCreationStatement(node, newStatements, componentName,
741 export function createComponentCreationStatement(node: ts.Statement, innerStatements: ts.Statement[…
746 blockArr.push(processDebug(node, nameResult, innerStatements, true));
749 createInitRenderStatement(node, immutableStatements, blockArr);
793 function createInitRenderStatement(node: ts.Statement,
810 ts.isExpressionStatement(node) ?
811 createComponent(node, COMPONENT_POP_FUNCTION).newNode : createIfPop()
821 function processItemComponent(node: ts.ExpressionStatement, nameResult: NameResult, innerCompStatem…
826 const res: CreateResult = createComponent(node, COMPONENT_CREATE_FUNCTION);
827 const isLazyCreate: boolean = checkLazyCreate(node, nameResult);
830 const etsComponentResult: EtsComponentResult = parseEtsComponentExpression(node);
833 …bindComponentAttr(node, res.identifierNode, itemRenderInnerStatements, log, true, false, immutable…
838 …bindComponentAttr(node, res.identifierNode, itemRenderInnerStatements, log, true, false, immutable…
843 node, itemRenderInnerStatements, deepItemRenderInnerStatements, nameResult, isLazyCreate,
847 node, itemRenderInnerStatements, deepItemRenderInnerStatements, nameResult, isLazyCreate,
872 node: ts.ExpressionStatement,
879 createItemCreation(node, itemRenderInnerStatements, nameResult, immutableStatements)
883 createDeepRenderFunction(node, deepItemRenderInnerStatements),
892 createComponent(node, COMPONENT_POP_FUNCTION).newNode
896 createObservedDeepRender(node, deepItemRenderInnerStatements),
904 function checkLazyCreate(node: ts.ExpressionStatement, nameResult: NameResult): boolean {
910 if (isLazyForEachChild(node)) {
919 node: ts.ExpressionStatement,
941 processDebug(node, nameResult, itemRenderInnerStatements, true),
948 [createComponent(node, COMPONENT_POP_FUNCTION).newNode],
966 node: ts.ExpressionStatement,
1002 createComponent(node, COMPONENT_POP_FUNCTION).newNode
1014 node: ts.ExpressionStatement,
1041 createComponent(node, COMPONENT_POP_FUNCTION).newNode
1052 function processTabAndNav(node: ts.ExpressionStatement, innerCompStatements: ts.Statement[],
1055 const TabContentComp: ts.EtsComponentExpression = getEtsComponentExpression(node);
1076 …bindComponentAttr(node, ts.factory.createIdentifier(name), tabAttrs, log, true, false, immutableSt…
1078 innerCompStatements, [tabContentCreation, ...tabAttrs], node, isGlobalBuilder, false,
1084 …bindComponentAttr(node, ts.factory.createIdentifier(name), tabAttrs, log, true, false, immutableSt…
1086 innerCompStatements, [tabContentCreation, ...tabAttrs], node, isGlobalBuilder, false,
1096 function getRealNodePos(node: ts.Node): number {
1098 if (node.pos === -1 && node.expression) {
1100 return getRealNodePos(node.expression);
1102 return node.getStart();
1106 function processForEachComponent(node: ts.ExpressionStatement, newStatements: ts.Statement[],
1110 node.expression.expression as ts.Identifier,
1112 if (ts.isCallExpression(node.expression)) {
1114 node.expression.expression as ts.Identifier,
1117 const argumentsArray: ts.Expression[] = Array.from(node.expression.arguments);
1126 processForEachBlock(node.expression, log, isBuilder) as ts.ArrowFunction;
1130 node = addForEachId(ts.factory.updateExpressionStatement(node, ts.factory.updateCallExpression(
1131 … node.expression, propertyNode, node.expression.typeArguments, argumentsArray)), isGlobalBuilder);
1133 newStatements.push(node, popNode);
1136 function processForEachComponentNew(node: ts.ExpressionStatement, newStatements: ts.Statement[],
1140 (node.expression as ts.CallExpression).expression as ts.Identifier,
1142 if (ts.isCallExpression(node.expression)) {
1143 const argumentsArray: ts.Expression[] = Array.from(node.expression.arguments);
1146 node.expression.expression as ts.Identifier,
1149 … processForEachBlock(node.expression, log, false, isGlobalBuilder) as ts.NodeArray<ts.Statement>;
1150 …const itemGenFunctionStatement: ts.VariableStatement = createItemGenFunctionStatement(node.express…
1152 …const itemIdFuncStatement: ts.VariableStatement = createItemIdFuncStatement(node.expression, argum…
1155 if (node.expression.expression.getText() === COMPONENT_FOREACH) {
1157 …newStatements.push(createComponentCreationStatement(node, newForEachStatements, COMPONENT_FOREACH,…
1170 node: ts.CallExpression,
1179 ts.factory.createIdentifier(node.expression.getText() === COMPONENT_FOREACH ?
1221 function getParameters(node: ts.ArrowFunction): ts.ParameterDeclaration[] {
1226 if (node.parameters && node.parameters.length > 1) {
1227 parameterArr.push(node.parameters[1]);
1233 node: ts.CallExpression,
1241 ts.factory.createIdentifier(node.expression.getText() === COMPONENT_FOREACH ?
1320 function addForEachId(node: ts.ExpressionStatement, isGlobalBuilder: boolean = false): ts.Expressio…
1321 const forEachComponent: ts.CallExpression = node.expression as ts.CallExpression;
1322 return ts.factory.updateExpressionStatement(node, ts.factory.updateCallExpression(
1338 function processForEachBlock(node: ts.CallExpression, log: LogInfo[],
1340 if (node.arguments.length > 1 && ts.isArrowFunction(node.arguments[1])) {
1341 const isLazy: boolean = node.expression.getText() === COMPONENT_LAZYFOREACH;
1342 const arrowNode: ts.ArrowFunction = node.arguments[1] as ts.ArrowFunction;
1344 if (node.arguments.length > 2 && !ts.isArrowFunction(node.arguments[2])) {
1389 function processIfStatement(node: ts.IfStatement, newStatements: ts.Statement[],
1392 …const newIfNode: ts.IfStatement = processInnerIfStatement(node, 0, log, isBuilder, isGlobalBuilder…
1397 …newStatements.push(createComponentCreationStatement(node, [ifCreate, newIfNode], COMPONENT_IF, isG…
1401 function processInnerIfStatement(node: ts.IfStatement, id: number, log: LogInfo[],
1403 if (ts.isIdentifier(node.expression) && node.expression.originalKeywordKind === undefined &&
1404 !node.expression.escapedText) {
1408 pos: node.expression.getStart()
1410 node = ts.factory.updateIfStatement(node, ts.factory.createIdentifier(COMPONENT_IF_UNDEFINED),
1411 node.thenStatement, node.elseStatement);
1413 …const newThenStatement: ts.Statement = processThenStatement(node.thenStatement, id, log, isBuilder…
1414 …const newElseStatement: ts.Statement = processElseStatement(node.elseStatement, id, log, isBuilder…
1416 node, node.expression, newThenStatement, newElseStatement);
1542 function createComponent(node: ts.ExpressionStatement, type: string): CreateResult {
1544 newNode: node,
1551 let temp: any = node.expression;
1599 function checkContainer(name: string, node: ts.Node): boolean {
1601 (node && node.arguments && node.arguments.length &&
1602 ts.isObjectLiteralExpression(node.arguments[0]) && node.arguments[0].properties &&
1603 checkComponentType(node.arguments[0].properties)));
1641 export function bindComponentAttr(node: ts.ExpressionStatement, identifierNode: ts.Identifier,
1645 let temp: any = node.expression;
1658 message: `'${node.getText()}' does not meet UI component syntax.`,
1659 pos: node.getStart()
1725 function parseRecycleId(node: ts.CallExpression, attr: ts.Identifier, isRecycleComponent: boolean,
1728 componentAttrInfo.reuseId = node.arguments[0];
1732 function processCustomBuilderProperty(node: ts.CallExpression, identifierNode: ts.Identifier,
1735 node.arguments.forEach((argument: ts.Expression | ts.Identifier, index: number) => {
1744 node = ts.factory.updateCallExpression(node, node.expression, node.typeArguments, newArguments);
1745 return node;
1761 function parseBuilderNode(node: ts.Node, propertyName: string):
1763 if (isPropertyAccessExpressionNode(node)) {
1765 return processPropertyBuilderWithoutKey(node as ts.PropertyAccessExpression);
1767 return processPropertyBuilder(node as ts.PropertyAccessExpression);
1769 } else if (ts.isIdentifier(node) && CUSTOM_BUILDER_METHOD.has(node.escapedText.toString())) {
1771 return processIdentifierBuilderWithoutKey(node);
1773 return processIdentifierBuilder(node);
1775 } else if (ts.isCallExpression(node)) {
1777 return getParsedBuilderAttrArgumentWithParamsWithoutKey(node);
1779 return getParsedBuilderAttrArgumentWithParams(node);
1781 } else if (ts.isObjectLiteralExpression(node)) {
1782 return processObjectPropertyBuilder(node);
1786 export function processObjectPropertyBuilder(node: ts.ObjectLiteralExpression): ts.ObjectLiteralExp…
1788 node.properties.forEach((property: ts.PropertyAssignment) => {
1816 return ts.factory.updateObjectLiteralExpression(node, newProperties);
1831 function isInnerBuilderCallExpressionNode(node: ts.Node): boolean {
1832 …return ts.isCallExpression(node) && node.expression && isPropertyAccessExpressionNode(node.express…
1835 function isGlobalBuilderCallExpressionNode(node: ts.Node): boolean {
1836 return ts.isCallExpression(node) && node.expression && ts.isIdentifier(node.expression) &&
1837 CUSTOM_BUILDER_METHOD.has(node.expression.escapedText.toString());
1840 function isPropertyAccessExpressionNode(node: ts.Node): boolean {
1841 return ts.isPropertyAccessExpression(node) && node.expression &&
1842 node.expression.kind === ts.SyntaxKind.ThisKeyword && node.name && ts.isIdentifier(node.name) &&
1843 CUSTOM_BUILDER_METHOD.has(node.name.escapedText.toString());
1846 function processBindPopupBuilder(node: ts.CallExpression): ts.CallExpression {
1848 node.arguments.forEach((argument: ts.ObjectLiteralExpression, index: number) => {
1856 node = ts.factory.updateCallExpression(node, node.expression, node.typeArguments, newArguments);
1857 return node;
1860 function processDragStartBuilder(node: ts.CallExpression, propertyName: string): ts.CallExpression {
1862 if (isNodeFunction(node)) {
1864 for (let i = 0; i < node.arguments[0].body.statements.length; i++) {
1866 const statement: ts.Statement = node.arguments[0].body.statements[i];
1869 …node = ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [ts.factory.upda…
1871 node.arguments[0], undefined, undefined, node.arguments[0].parameters, node.arguments[0].type,
1873 …node.arguments[0].equalsGreaterThanToken, ts.factory.updateBlock(node.arguments[0].body, newStatem…
1875 return node;
1878 function isNodeFunction(node: ts.CallExpression): boolean {
1879 …return node.arguments && node.arguments.length && ts.isArrowFunction(node.arguments[0]) && node.ar…
1880 ts.isBlock(node.arguments[0].body);
1928 function processBindPopupBuilderProperty(node: ts.ObjectLiteralExpression): ts.ObjectLiteralExpress…
1930 node.properties.forEach((property: ts.PropertyAssignment, index: number) => {
1940 return ts.factory.updateObjectLiteralExpression(node, newProperties);
1962 function processPropertyBuilder(node: ts.PropertyAccessExpression): ts.ObjectLiteralExpression {
1968 node,
1978 function processPropertyBuilderWithoutKey(node: ts.PropertyAccessExpression): ts.CallExpression {
1981 node,
1989 function processIdentifierBuilder(node: ts.Identifier): ts.ObjectLiteralExpression {
1994 … ts.factory.createPropertyAccessExpression(node, ts.factory.createIdentifier(BUILDER_ATTR_BIND)),
2001 function processIdentifierBuilderWithoutKey(node: ts.Identifier): ts.CallExpression {
2003 ts.factory.createPropertyAccessExpression(node, ts.factory.createIdentifier(BUILDER_ATTR_BIND)),
2008 function getParsedBuilderAttrArgumentWithParams(node: ts.CallExpression):
2021 … ts.factory.createPropertyAccessExpression(node.expression, ts.factory.createIdentifier(CALL)
2022 ), undefined, [ts.factory.createThis(), ...node.arguments]))],
2030 function getParsedBuilderAttrArgumentWithParamsWithoutKey(node: ts.CallExpression):
2040 ts.factory.createPropertyAccessExpression(node.expression, ts.factory.createIdentifier(CALL)
2041 ), undefined, [ts.factory.createThis(), ...node.arguments]))],
2047 function validatePropertyAccessExpressionWithCustomBuilder(node: ts.Node): boolean {
2048 return ts.isPropertyAccessExpression(node) && node.name &&
2049 ts.isIdentifier(node.name) && CUSTOM_BUILDER_PROPERTIES.has(node.name.escapedText.toString());
2052 function validateIdentifierWithCustomBuilder(node: ts.Node): boolean {
2053 return ts.isIdentifier(node) && CUSTOM_BUILDER_PROPERTIES.has(node.escapedText.toString());
2095 function verifyComponentId(temp: any, node: ts.Identifier, propName: string,
2101 .getLineAndCharacterOfPosition(getRealNodePos(node));
2116 pos: node.pos
2127 function addComponentAttr(temp: any, node: ts.Identifier, lastStatement: any,
2132 const propName: string = node.getText();
2133 verifyComponentId(temp, node, propName, log);
2137 createFunction(ts.factory.createIdentifier(GLOBAL_CONTEXT), node,
2149 ts.factory.createIdentifier(GLOBAL_CONTEXT), node, temp.arguments));
2210 createFunction(identifierNode, node, argumentsArr));
2223 createFunction(identifierNode, node, temp.arguments));
2236 function isGestureType(node: ts.Identifier): boolean {
2237 return GESTURE_TYPE_NAMES.has(node.escapedText.toString());
2247 function isRegularAttrNode(node: ts.Expression): boolean {
2248 if (ts.isObjectLiteralExpression(node)) {
2249 return node.properties.every((propNode: ts.PropertyAssignment) => {
2256 if (ts.isArrayLiteralExpression(node)) {
2257 return node.elements.every((child: ts.Expression) => {
2262 if (isLiteralNode(node)) {
2266 if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) &&
2267 ts.isIdentifier(node.name)) {
2268 if (enumCollection.has(node.expression.escapedText.toString())) {
2272 const type: ts.Type = globalProgram.checker.getTypeAtLocation(node);
2282 if (ts.isPropertyAccessExpression(node)) {
2283 traversePropNode(node, result);
2288 function isLiteralNode(node: ts.Expression): boolean {
2289 return ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isArrowFunction(node) ||
2290 [ts.SyntaxKind.TrueKeyword, ts.SyntaxKind.FalseKeyword].includes(node.kind);
2293 function traversePropNode(node: ts.PropertyAccessExpression, result: AttrResult): void {
2294 if (node.expression.kind === ts.SyntaxKind.ThisKeyword && ts.isIdentifier(node.name) &&
2295 …regularCollection.get(componentCollection.currentClassName).has(node.name.escapedText.toString()))…
2299 if (ts.isPropertyAccessExpression(node.expression)) {
2300 traversePropNode(node.expression, result);
2320 function loopEtscomponent(node: any, isStylesAttr: boolean): ts.Node {
2321 node.arguments.forEach((item: ts.Node, index: number) => {
2323 node.arguments[index] = ts.factory.createCallExpression(
2327 node.arguments[index] = ts.visitEachChild(item,
2331 return node;
2334 function changeEtsComponentKind(node: ts.Node): ts.Node {
2335 if (ts.isEtsComponentExpression(node)) {
2336 node.kind = 204;
2337 return node;
2339 return ts.visitEachChild(node, changeEtsComponentKind, contextGlobal);
2462 function parseGesture(node: ts.CallExpression, propName: string, statements: ts.Statement[],
2469 parseGestureInterface(node, statements, log, updateStatements);
2476 if (node.arguments && node.arguments.length > 1 &&
2477 ts.isPropertyAccessExpression(node.arguments[1])) {
2479 argumentArr.push(node.arguments[1]);
2488 function processGestureType(node: ts.CallExpression, statements: ts.Statement[], log: LogInfo[],
2491 const newNode: ts.ExpressionStatement = ts.factory.createExpressionStatement(node);
2492 let temp: any = node.expression;
2524 function parseGestureInterface(node: ts.CallExpression, statements: ts.Statement[], log: LogInfo[],
2526 if (node.arguments && node.arguments.length) {
2527 node.arguments.forEach((item: ts.Node) => {
2535 export function getName(node: ts.ExpressionStatement | ts.Expression): string {
2537 let temp: any = node.expression;
2565 export function isAttributeNode(node: ts.ExpressionStatement): boolean {
2566 let temp: any = node.expression;
2588 function isEtsComponent(node: ts.ExpressionStatement): boolean {
2590 let temp: any = node.expression;
2607 function isParamFunction(node: ts.ExpressionStatement): boolean {
2608 return node.expression && ts.isCallExpression(node.expression) &&
2609 node.expression.expression && ts.isIdentifier(node.expression.expression);
2612 function getComponentType(node: ts.ExpressionStatement, log: LogInfo[], name: string,
2615 if (forEachParameters && isSomeName(forEachParameters, name) && isParamFunction(node)) {
2618 if (isEtsComponent(node)) {
2634 judgeBuilderType(node)) {
2637 ts.isCallExpression(node.expression) && ts.isIdentifier(node.expression.expression)) {
2639 } else if (!isAttributeNode(node)) {
2642 message: `'${node.getText()}' does not meet UI component syntax.`,
2643 pos: node.getStart()
2649 function judgeBuilderType(node: ts.ExpressionStatement): boolean {
2656 if (node.expression && node.expression.expression && checker) {
2657 const type: ts.Type = checker.getTypeAtLocation(node.expression.expression);
2673 function getEtsComponentExpression(node:ts.ExpressionStatement): ts.EtsComponentExpression {
2674 let current: any = node.expression;
2684 function checkEtsAndIdInIf(node:ts.ExpressionStatement, parent: string): [ts.EtsComponentExpression…
2685 let current: any = node.expression;
2701 function checkIdInIf(node:ts.ExpressionStatement, parent: string): ts.Expression {
2702 let current: any = node.expression;
2716 function checkEtsComponent(node: ts.ExpressionStatement, log: LogInfo[]): void {
2717 const etsComponentExpression: ts.EtsComponentExpression = getEtsComponentExpression(node);
2728 function checkButtonParamHasLabel(node: ts.EtsComponentExpression, log: LogInfo[]): void {
2729 if (node.arguments && node.arguments.length !== 0) {
2730 for (let i = 0; i < node.arguments.length; i++) {
2731 let argument: ts.Expression = node.arguments[i];
2737 pos: node.getStart()
2745 function isLazyForEachChild(node: ts.ExpressionStatement): boolean {
2746 let temp: any = node.parent;
2777 export function createFunction(node: ts.Identifier, attrNode: ts.Identifier,
2780 const compName: string = node.escapedText.toString();
2786 if (checkCreateArgumentBuilder(node, attrNode)) {
2795 node,
2803 function checkCreateArgumentBuilder(node: ts.Identifier, attrNode: ts.Identifier): boolean {
2805 CREATE_BIND_COMPONENT.has(node.escapedText.toString())) {