Lines Matching refs:node
185 export function processComponentBuild(node: ts.MethodDeclaration,
194 if (node.body && node.body.statements && node.body.statements.length &&
195 validateRootNode(node, log)) {
196 newNode = ts.factory.updateMethodDeclaration(node, ts.getModifiers(node),
197 node.asteriskToken, renderNode, node.questionToken, node.typeParameters, node.parameters,
198 node.type, processComponentBlock(node.body, false, log));
200 newNode = ts.factory.updateMethodDeclaration(node, ts.getModifiers(node),
201 node.asteriskToken, renderNode, node.questionToken, node.typeParameters, node.parameters,
202 node.type, node.body);
245 export function processComponentBlock(node: ts.Block, isLazy: boolean, log: LogInfo[],
251 …processComponentChild(node, newStatements, log, {isAcceleratePreview: false, line: 0, column: 0, f…
280 return ts.factory.updateBlock(node, [
286 return ts.factory.updateBlock(node, newStatements);
307 function visitComponent(node: ts.Node): void {
308 if (storedFileInfo.lazyForEachInfo && !ts.isBlock(node)) {
309 ts.forEachChild(node, (child: ts.Node) => {
325 function forkBuilderParamNode(node: ts.ParameterDeclaration): ts.Statement {
326 const paramNode: ts.Identifier = node.name as ts.Identifier;
341 function validateRootNode(node: ts.MethodDeclaration, log: LogInfo[]): boolean {
343 if (node.body.statements.length === 1) {
344 const statement: ts.Statement = node.body.statements[0];
355 pos: node.body.statements.pos
361 function validateFirstNode(node: ts.Statement): boolean {
364 if (isEntryComponent && !validateContainerComponent(node)) {
370 function validateContainerComponent(node: ts.Statement): boolean {
371 if (ts.isExpressionStatement(node) && node.expression &&
372 (ts.isEtsComponentExpression(node.expression) || ts.isCallExpression(node.expression))) {
373 const nameResult: NameResult = { name: null, node: null, arguments: [] }; constant
374 validateEtsComponentNode(node.expression, nameResult);
375 if (nameResult.name && checkContainer(nameResult.name, nameResult.node)) {
399 node?: ts.Node
402 function validateEtsComponentNode(node: ts.CallExpression | ts.EtsComponentExpression, result?: Nam…
403 let childNode: ts.Node = node;
412 result.node = childNode;
423 export function processComponentChild(node: ts.Block | ts.SourceFile, newStatements: ts.Statement[],
435 …sourceNode = ts.createSourceFile('', node.getText(), ts.ScriptTarget.Latest, true, ts.ScriptKind.E…
437 if (node.statements.length) {
440 node.statements.forEach((item) => {
547 export function transferBuilderCall(node: ts.ExpressionStatement, name: string,
549 if (node.expression && ts.isCallExpression(node.expression)) {
552 node.expression.expression,
558 newNode.expression.questionDotToken = node.expression.questionDotToken;
559 …if (node.expression.arguments && node.expression.arguments.length === 1 && ts.isObjectLiteralExpre…
568 traverseBuilderParams(node.expression.arguments[0], isBuilder)
577 … storedFileInfo.lazyForEachInfo.forEachParameters || isBuilder)) ? node.expression.arguments :
578 … [...node.expression.arguments, ts.factory.createNull(), ts.factory.createIdentifier(MY_IDS)]
584 function traverseBuilderParams(node: ts.ObjectLiteralExpression,
587 if (node.properties && node.properties.length) {
588 node.properties.forEach(property => {
659 function addInnerBuilderParameter(node: ts.ExpressionStatement,
661 if (node.expression && ts.isCallExpression(node.expression) && node.expression.arguments) {
662 …node.expression.arguments.push(isGlobalBuilder ? parentConditionalExpression() : ts.factory.create…
663 return ts.factory.createExpressionStatement(ts.factory.updateCallExpression(node.expression,
664 node.expression.expression, node.expression.typeArguments, node.expression.arguments));
666 return node;
670 function processExpressionStatementChange(node: ts.ExpressionStatement, nextNode: ts.Block,
674 if (node.expression.expression && ts.isIdentifier(node.expression.expression)) {
675 name = node.expression.expression.escapedText.toString();
679 return processBlockToExpression(node, nextNode, log, name);
685 pos: node.getStart()
691 function processBlockToExpression(node: ts.ExpressionStatement, nextNode: ts.Block,
700 let argumentsArray: ts.ObjectLiteralExpression[] = node.expression.arguments;
706 node.expression.arguments[0].properties.concat([newPropertyAssignment]), true)];
710 node.expression, node.expression.expression, node.expression.expression.typeArguments,
713 node.expression.expression.parent = callNode;
715 callNode.parent = node.expression.parent;
716 node = ts.factory.updateExpressionStatement(node, callNode);
717 return node;
724 function parseEtsComponentExpression(node: ts.ExpressionStatement): EtsComponentResult {
727 let temp: any = node.expression;
753 function processInnerComponent(node: ts.ExpressionStatement, innerCompStatements: ts.Statement[],
758 const res: CreateResult = createComponent(node, COMPONENT_CREATE_FUNCTION);
761 validateEtsComponentNode(node.expression as ts.EtsComponentExpression, nameResult);
763 checkNonspecificParents(node, nameResult.name, savedParent, log);
766 …processItemComponent(node, nameResult, innerCompStatements, log, parent, isGlobalBuilder, idName, …
768 …processTabAndNav(node, innerCompStatements, nameResult, log, parent, isGlobalBuilder, idName, buil…
770 …processNormalComponent(node, nameResult, innerCompStatements, log, parent, isBuilder, isGlobalBuil…
775 function processNormalComponent(node: ts.ExpressionStatement, nameResult: NameResult,
784 const res: CreateResult = createComponent(node, COMPONENT_CREATE_FUNCTION);
786 processDebug(node, nameResult, newStatements);
787 const etsComponentResult: EtsComponentResult = parseEtsComponentExpression(node);
797 newStatements.splice(-2, 1, createComponent(node, COMPONENT_CREATE_CHILD_FUNCTION).newNode);
799 newStatements.splice(-1, 1, createComponent(node, COMPONENT_CREATE_CHILD_FUNCTION).newNode);
803 … bindComponentAttr(node, res.identifierNode, newStatements, log, true, false, immutableStatements);
805 processInnerCompStatements(innerCompStatements, newStatements, node, isGlobalBuilder,
812 … bindComponentAttr(node, res.identifierNode, newStatements, log, true, false, immutableStatements);
813 processInnerCompStatements(innerCompStatements, newStatements, node, isGlobalBuilder,
817 innerCompStatements.push(createComponent(node, COMPONENT_POP_FUNCTION).newNode);
846 function processDebug(node: ts.Statement, nameResult: NameResult, newStatements: ts.Statement[],
855 posOfNode = sourceNode.getLineAndCharacterOfPosition(getRealNodePos(node) - 22);
862 posOfNode = transformLog.sourceFile.getLineAndCharacterOfPosition(getRealNodePos(node));
890 …newStatements: ts.Statement[], node: ts.Statement, isGlobalBuilder: boolean, isTransition: boolean,
896 innerCompStatements.push(createComponentCreationStatement(node, newStatements, componentName,
919 export function createComponentCreationStatement(node: ts.Statement, innerStatements: ts.Statement[…
925 blockArr.push(processDebug(node, nameResult, innerStatements, true));
928 createInitRenderStatement(node, immutableStatements, blockArr);
967 function createInitRenderStatement(node: ts.Statement,
984 ts.isExpressionStatement(node) ?
985 createComponent(node, COMPONENT_POP_FUNCTION).newNode : createIfPop()
995 function processItemComponent(node: ts.ExpressionStatement, nameResult: NameResult, innerCompStatem…
1004 const res: CreateResult = createComponent(node, COMPONENT_CREATE_FUNCTION);
1005 const isLazyCreate: boolean = checkLazyCreate(node, nameResult);
1008 const etsComponentResult: EtsComponentResult = parseEtsComponentExpression(node);
1011 …bindComponentAttr(node, res.identifierNode, itemRenderInnerStatements, log, true, false, immutable…
1018 …bindComponentAttr(node, res.identifierNode, itemRenderInnerStatements, log, true, false, immutable…
1023 node, itemRenderInnerStatements, deepItemRenderInnerStatements, nameResult, isLazyCreate,
1027 node, itemRenderInnerStatements, deepItemRenderInnerStatements, nameResult, isLazyCreate,
1071 node: ts.ExpressionStatement,
1080 createItemCreation2(node, itemRenderInnerStatements, nameResult, immutableStatements,
1085 blockNode.unshift(createItemCreation(node, isGlobalBuilder, builderParamsResult));
1087 …createDeepRenderFunction(node, deepItemRenderInnerStatements, isGlobalBuilder, builderParamsResult…
1094 createComponent(node, COMPONENT_POP_FUNCTION).newNode
1098 blockNode.unshift(createItemCreation(node, isGlobalBuilder, builderParamsResult));
1101 createObservedDeepRender(node, deepItemRenderInnerStatements, itemCreation),
1109 function checkLazyCreate(node: ts.ExpressionStatement, nameResult: NameResult): boolean {
1115 if (isLazyForEachChild(node)) {
1123 function createItemCreation(node: ts.ExpressionStatement, isGlobalBuilder: boolean,
1146 [createComponent(node, COMPONENT_POP_FUNCTION).newNode],
1162 node: ts.ExpressionStatement,
1171 processDebug(node, nameResult, itemRenderInnerStatements, true)
1207 node: ts.ExpressionStatement,
1228 createComponent(node, COMPONENT_POP_FUNCTION).newNode
1250 node: ts.ExpressionStatement,
1276 createComponent(node, COMPONENT_POP_FUNCTION).newNode
1287 function processTabAndNav(node: ts.ExpressionStatement, innerCompStatements: ts.Statement[],
1291 const TabContentComp: ts.EtsComponentExpression = getEtsComponentExpression(node);
1316 …bindComponentAttr(node, ts.factory.createIdentifier(name), tabAttrs, log, true, false, immutableSt…
1318 innerCompStatements, [tabContentCreation, ...tabAttrs], node, isGlobalBuilder, false,
1325 …bindComponentAttr(node, ts.factory.createIdentifier(name), tabAttrs, log, true, false, immutableSt…
1327 innerCompStatements, [tabContentCreation, ...tabAttrs], node, isGlobalBuilder, false,
1337 export function getRealNodePos(node: ts.Node): number {
1339 if (node.pos === -1 && node.expression) {
1341 return getRealNodePos(node.expression);
1343 return node.getStart();
1347 function processForEachComponent(node: ts.ExpressionStatement, newStatements: ts.Statement[],
1351 node.expression.expression as ts.Identifier,
1353 if (ts.isCallExpression(node.expression)) {
1355 node.expression.expression as ts.Identifier,
1358 const argumentsArray: ts.Expression[] = Array.from(node.expression.arguments);
1366 const newForEachArrowFunc: ts.ArrowFunction = processForEachFunctionBlock(node.expression);
1368 … processForEachBlock(node.expression, log, newForEachArrowFunc, isBuilder, ) as ts.ArrowFunction;
1372 node = addForEachId(ts.factory.updateExpressionStatement(node, ts.factory.updateCallExpression(
1373 … node.expression, propertyNode, node.expression.typeArguments, argumentsArray)), isGlobalBuilder);
1375 newStatements.push(node, popNode);
1378 function processForEachComponentNew(node: ts.ExpressionStatement, newStatements: ts.Statement[],
1382 (node.expression as ts.CallExpression).expression as ts.Identifier,
1384 if (ts.isCallExpression(node.expression)) {
1385 if (checkForEachComponent(node)) {
1390 const argumentsArray: ts.Expression[] = Array.from(node.expression.arguments);
1393 node.expression.expression as ts.Identifier,
1395 const newForEachArrowFunc: ts.ArrowFunction = processForEachFunctionBlock(node.expression);
1397 processForEachBlock(node.expression, log, newForEachArrowFunc, false, isGlobalBuilder,
1399 …const itemGenFunctionStatement: ts.VariableStatement = createItemGenFunctionStatement(node.express…
1400 …const itemIdFuncStatement: ts.VariableStatement = createItemIdFuncStatement(node.expression, argum…
1403 if (node.expression.expression.getText() === COMPONENT_FOREACH) {
1405 … newStatements.push(createComponentCreationStatement(node, newForEachStatements, COMPONENT_FOREACH,
1415 if (checkForEachComponent(node)) {
1423 function checkForEachComponent(node: ts.ExpressionStatement): boolean {
1424 return node.expression.expression && ts.isIdentifier(node.expression.expression) &&
1425 node.expression.expression.getText() === COMPONENT_FOREACH;
1429 node: ts.CallExpression,
1438 ts.factory.createIdentifier(node.expression.getText() === COMPONENT_FOREACH ?
1482 function getParameters(node: ts.ArrowFunction): ts.ParameterDeclaration[] {
1487 if (node.parameters && node.parameters.length > 1) {
1488 parameterArr.push(node.parameters[1]);
1491 if (node.parameters.length === 1) {
1506 node: ts.CallExpression,
1514 ts.factory.createIdentifier(node.expression.getText() === COMPONENT_FOREACH ?
1597 function addForEachId(node: ts.ExpressionStatement, isGlobalBuilder: boolean = false): ts.Expressio…
1598 const forEachComponent: ts.CallExpression = node.expression as ts.CallExpression;
1599 return ts.factory.updateExpressionStatement(node, ts.factory.updateCallExpression(
1614 function processForEachFunctionBlock(node: ts.CallExpression): ts.ArrowFunction {
1615 if (ts.isArrowFunction(node.arguments[1])) {
1616 return node.arguments[1];
1617 …} else if (ts.isParenthesizedExpression(node.arguments[1]) && ts.isArrowFunction(node.arguments[1]…
1618 return node.arguments[1].expression;
1623 function processForEachBlock(node: ts.CallExpression, log: LogInfo[],
1626 if (node.arguments.length > 1 && ts.isArrowFunction(arrowNode)) {
1627 const isLazy: boolean = node.expression.getText() === COMPONENT_LAZYFOREACH;
1675 function processIfStatement(node: ts.IfStatement, newStatements: ts.Statement[],
1684 …const newIfNode: ts.IfStatement = processInnerIfStatement(node, 0, log, isBuilder, isGlobalBuilder…
1690 newStatements.push(createComponentCreationStatement(node, ifStatements, COMPONENT_IF,
1695 function processInnerIfStatement(node: ts.IfStatement, id: number, log: LogInfo[],
1698 if (ts.isIdentifier(node.expression) && node.expression.originalKeywordKind === undefined &&
1699 !node.expression.escapedText) {
1703 pos: node.expression.getStart()
1705 node = ts.factory.updateIfStatement(node, ts.factory.createIdentifier(COMPONENT_IF_UNDEFINED),
1706 node.thenStatement, node.elseStatement);
1708 …const newThenStatement: ts.Statement = processThenStatement(node.thenStatement, id, log, isBuilder…
1709 …const newElseStatement: ts.Statement = processElseStatement(node.elseStatement, id, log, isBuilder…
1711 node, node.expression, newThenStatement, newElseStatement);
1839 function createComponent(node: ts.ExpressionStatement, type: string): CreateResult {
1841 newNode: node,
1848 let temp: any = node.expression;
1896 function checkContainer(name: string, node: ts.Node): boolean {
1898 (node && node.arguments && node.arguments.length &&
1899 ts.isObjectLiteralExpression(node.arguments[0]) && node.arguments[0].properties &&
1900 checkComponentType(node.arguments[0].properties)));
1938 export function bindComponentAttr(node: ts.ExpressionStatement, identifierNode: ts.Identifier,
1942 let temp: any = node.expression;
1955 message: `'${node.getText()}' does not meet UI component syntax.`,
1956 pos: node.getStart()
2022 function parseRecycleId(node: ts.CallExpression, attr: ts.Identifier, isRecycleComponent: boolean,
2025 componentAttrInfo.reuseId = node.arguments[0];
2029 function processCustomBuilderProperty(node: ts.CallExpression, identifierNode: ts.Identifier,
2032 node.arguments.forEach((argument: ts.Expression | ts.Identifier, index: number) => {
2041 node = ts.factory.updateCallExpression(node, node.expression, node.typeArguments, newArguments);
2042 return node;
2060 export function isWrappedBuilder(node: ts.PropertyAccessExpression): boolean {
2061 if (projectConfig.minAPIVersion >= 11 && ts.isPropertyAccessExpression(node) &&
2062 …node.name && ts.isIdentifier(node.name) && node.name.escapedText.toString() === WRAPBUILDER_BUILDE…
2063 globalProgram.checker.getTypeAtLocation(node.expression) &&
2064 globalProgram.checker.getTypeAtLocation(node.expression).symbol &&
2065 …globalProgram.checker.getTypeAtLocation(node.expression).symbol.escapedName === WRAPPEDBUILDER_CLA…
2071 function isWrappedBuilderCallExpression(node: ts.CallExpression): boolean {
2072 if (projectConfig.minAPIVersion >= 11 && ts.isCallExpression(node) && node.expression &&
2073 isWrappedBuilder(node.expression as ts.PropertyAccessExpression)) {
2079 function parseBuilderNode(node: ts.Node, propertyName: string):
2081 …if (isWrappedBuilder(node as ts.PropertyAccessExpression) || isPropertyAccessExpressionNode(node))…
2083 return processPropertyBuilderWithoutKey(node as ts.PropertyAccessExpression);
2085 return processPropertyBuilder(node as ts.PropertyAccessExpression);
2087 …} else if (ts.isIdentifier(node) && storedFileInfo.builderLikeCollection.has(node.escapedText.toSt…
2089 return processIdentifierBuilderWithoutKey(node);
2091 return processIdentifierBuilder(node);
2093 …} else if (isWrappedBuilderCallExpression(node as ts.CallExpression) || ts.isCallExpression(node))…
2095 return getParsedBuilderAttrArgumentWithParamsWithoutKey(node);
2097 return getParsedBuilderAttrArgumentWithParams(node);
2099 } else if (ts.isObjectLiteralExpression(node)) {
2100 return processObjectPropertyBuilder(node);
2104 export function processObjectPropertyBuilder(node: ts.ObjectLiteralExpression): ts.ObjectLiteralExp…
2106 node.properties.forEach((property: ts.PropertyAssignment) => {
2134 return ts.factory.updateObjectLiteralExpression(node, newProperties);
2137 function trans$$inCustomBuilder(node: ts.CallExpression): ts.Expression[] {
2139 if (node.expression && ts.isIdentifier(node.expression)) {
2140 name = node.expression.escapedText.toString();
2141 } else if (node.expression && ts.isPropertyAccessExpression(node.expression) &&
2142 node.expression.name && ts.isIdentifier(node.expression.name)) {
2143 name = node.expression.name.escapedText.toString();
2145 if (node.arguments.length === 1 && ts.isObjectLiteralExpression(node.arguments[0])) {
2151 traverseBuilderParams(node.arguments[0], storedFileInfo.processBuilder)
2155 return node.arguments;
2172 function isInnerBuilderCallExpressionNode(node: ts.Node): boolean {
2173 …return ts.isCallExpression(node) && node.expression && isPropertyAccessExpressionNode(node.express…
2176 function isGlobalBuilderCallExpressionNode(node: ts.Node): boolean {
2177 return ts.isCallExpression(node) && node.expression && ts.isIdentifier(node.expression) &&
2178 CUSTOM_BUILDER_METHOD.has(node.expression.escapedText.toString());
2181 function isPropertyAccessExpressionNode(node: ts.Node): boolean {
2182 return ts.isPropertyAccessExpression(node) && node.expression &&
2183 node.expression.kind === ts.SyntaxKind.ThisKeyword && node.name && ts.isIdentifier(node.name) &&
2184 storedFileInfo.builderLikeCollection.has(node.name.escapedText.toString());
2187 function processBindPopupBuilder(node: ts.CallExpression): ts.CallExpression {
2189 node.arguments.forEach((argument: ts.ObjectLiteralExpression, index: number) => {
2197 node = ts.factory.updateCallExpression(node, node.expression, node.typeArguments, newArguments);
2198 return node;
2201 function processDragStartBuilder(node: ts.CallExpression, propertyName: string): ts.CallExpression {
2203 if (isNodeFunction(node)) {
2205 for (let i = 0; i < node.arguments[0].body.statements.length; i++) {
2207 const statement: ts.Statement = node.arguments[0].body.statements[i];
2210 …node = ts.factory.updateCallExpression(node, node.expression, node.typeArguments, [ts.factory.upda…
2212 node.arguments[0], undefined, undefined, node.arguments[0].parameters, node.arguments[0].type,
2214 …node.arguments[0].equalsGreaterThanToken, ts.factory.updateBlock(node.arguments[0].body, newStatem…
2216 return node;
2219 function isNodeFunction(node: ts.CallExpression): boolean {
2220 …return node.arguments && node.arguments.length && ts.isArrowFunction(node.arguments[0]) && node.ar…
2221 ts.isBlock(node.arguments[0].body);
2269 function processBindPopupBuilderProperty(node: ts.ObjectLiteralExpression): ts.ObjectLiteralExpress…
2271 node.properties.forEach((property: ts.PropertyAssignment, index: number) => {
2281 return ts.factory.updateObjectLiteralExpression(node, newProperties);
2303 function processPropertyBuilder(node: ts.PropertyAccessExpression): ts.ObjectLiteralExpression {
2309 node,
2319 function processPropertyBuilderWithoutKey(node: ts.PropertyAccessExpression): ts.CallExpression {
2322 node,
2330 function processIdentifierBuilder(node: ts.Identifier): ts.ObjectLiteralExpression {
2335 … ts.factory.createPropertyAccessExpression(node, ts.factory.createIdentifier(BUILDER_ATTR_BIND)),
2342 function processIdentifierBuilderWithoutKey(node: ts.Identifier): ts.CallExpression {
2344 ts.factory.createPropertyAccessExpression(node, ts.factory.createIdentifier(BUILDER_ATTR_BIND)),
2349 function getParsedBuilderAttrArgumentWithParams(node: ts.CallExpression):
2351 const newArguments: ts.Expression[] = trans$$inCustomBuilder(node);
2363 … ts.factory.createPropertyAccessExpression(node.expression, ts.factory.createIdentifier(CALL)
2372 function getParsedBuilderAttrArgumentWithParamsWithoutKey(node: ts.CallExpression):
2374 const newArguments: ts.Expression[] = trans$$inCustomBuilder(node);
2383 ts.factory.createPropertyAccessExpression(node.expression, ts.factory.createIdentifier(CALL)
2390 function validatePropertyAccessExpressionWithCustomBuilder(node: ts.Node): boolean {
2391 return ts.isPropertyAccessExpression(node) && node.name &&
2392 ts.isIdentifier(node.name) && CUSTOM_BUILDER_PROPERTIES.has(node.name.escapedText.toString());
2395 function validateIdentifierWithCustomBuilder(node: ts.Node): boolean {
2396 return ts.isIdentifier(node) && CUSTOM_BUILDER_PROPERTIES.has(node.escapedText.toString());
2437 function verifyComponentId(temp: any, node: ts.Identifier, propName: string,
2443 .getLineAndCharacterOfPosition(getRealNodePos(node));
2458 pos: node.pos
2469 function addComponentAttr(temp: any, node: ts.Identifier, lastStatement: any,
2474 const propName: string = node.getText();
2475 verifyComponentId(temp, node, propName, log);
2479 createFunction(ts.factory.createIdentifier(GLOBAL_CONTEXT), node,
2491 ts.factory.createIdentifier(GLOBAL_CONTEXT), node, temp.arguments));
2552 createFunction(identifierNode, node, argumentsArr));
2564 createFunction(identifierNode, node, temp.arguments, isAttributeModifier));
2577 function isGestureType(node: ts.Identifier): boolean {
2578 return GESTURE_TYPE_NAMES.has(node.escapedText.toString());
2588 function isRegularAttrNode(node: ts.Expression): boolean {
2589 if (ts.isObjectLiteralExpression(node)) {
2590 return node.properties.every((propNode: ts.PropertyAssignment) => {
2597 if (ts.isArrayLiteralExpression(node)) {
2598 return node.elements.every((child: ts.Expression) => {
2603 if (isLiteralNode(node)) {
2607 if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) &&
2608 ts.isIdentifier(node.name)) {
2609 if (enumCollection.has(node.expression.escapedText.toString())) {
2613 const type: ts.Type = globalProgram.checker.getTypeAtLocation(node);
2623 if (ts.isPropertyAccessExpression(node)) {
2624 traversePropNode(node, result);
2629 function isLiteralNode(node: ts.Expression): boolean {
2630 return ts.isStringLiteral(node) || ts.isNumericLiteral(node) || ts.isArrowFunction(node) ||
2631 [ts.SyntaxKind.TrueKeyword, ts.SyntaxKind.FalseKeyword].includes(node.kind);
2634 function traversePropNode(node: ts.PropertyAccessExpression, result: AttrResult): void {
2635 if (node.expression.kind === ts.SyntaxKind.ThisKeyword && ts.isIdentifier(node.name) &&
2636 …regularCollection.get(componentCollection.currentClassName).has(node.name.escapedText.toString()))…
2640 if (ts.isPropertyAccessExpression(node.expression)) {
2641 traversePropNode(node.expression, result);
2661 function loopEtscomponent(node: any, isStylesAttr: boolean): ts.Node {
2662 node.arguments.forEach((item: ts.Node, index: number) => {
2664 node.arguments[index] = ts.factory.createCallExpression(
2668 node.arguments[index] = ts.visitEachChild(item,
2672 return node;
2675 function changeEtsComponentKind(node: ts.Node): ts.Node {
2676 if (ts.isEtsComponentExpression(node)) {
2677 node.kind = 204;
2678 return node;
2680 return ts.visitEachChild(node, changeEtsComponentKind, contextGlobal);
2803 function parseGesture(node: ts.CallExpression, propName: string, statements: ts.Statement[],
2810 parseGestureInterface(node, statements, log, updateStatements);
2817 if (node.arguments && node.arguments.length > 1 &&
2818 ts.isPropertyAccessExpression(node.arguments[1])) {
2820 argumentArr.push(node.arguments[1]);
2829 function processGestureType(node: ts.CallExpression, statements: ts.Statement[], log: LogInfo[],
2832 const newNode: ts.ExpressionStatement = ts.factory.createExpressionStatement(node);
2833 let temp: any = node.expression;
2865 function parseGestureInterface(node: ts.CallExpression, statements: ts.Statement[], log: LogInfo[],
2867 if (node.arguments && node.arguments.length) {
2868 node.arguments.forEach((item: ts.Node) => {
2876 export function getName(node: ts.ExpressionStatement | ts.Expression): string {
2878 let temp: any = node.expression;
2906 export function isAttributeNode(node: ts.ExpressionStatement): boolean {
2907 let temp: any = node.expression;
2929 function isEtsComponent(node: ts.ExpressionStatement): boolean {
2931 let temp: any = node.expression;
2948 function isParamFunction(node: ts.ExpressionStatement): boolean {
2949 return node.expression && ts.isCallExpression(node.expression) &&
2950 node.expression.expression && ts.isIdentifier(node.expression.expression);
2953 function getComponentType(node: ts.ExpressionStatement, log: LogInfo[], name: string,
2956 if (forEachParameters && isSomeName(forEachParameters, name) && isParamFunction(node)) {
2959 if (isEtsComponent(node)) {
2965 } else if (!isPartMethod(node) && componentCollection.customComponents.has(name)) {
2969 } else if (CUSTOM_BUILDER_METHOD.has(name) && isBuilderName || isWrappedBuilderExpression(node)) {
2975 judgeBuilderType(node)) {
2978 ts.isCallExpression(node.expression) && ts.isIdentifier(node.expression.expression)) {
2980 } else if (!isAttributeNode(node)) {
2983 message: `'${node.getText()}' does not meet UI component syntax.`,
2984 pos: node.getStart()
2990 function isPartMethod(node: ts.ExpressionStatement): boolean {
2991 …if (ts.isCallExpression(node.expression) && ts.isPropertyAccessExpression(node.expression.expressi…
2992 node.expression.expression.expression && node.expression.expression.expression.kind &&
2993 node.expression.expression.expression.kind === ts.SyntaxKind.ThisKeyword) {
3000 function isWrappedBuilderExpression(node: ts.ExpressionStatement): boolean {
3001 if (projectConfig.minAPIVersion >= 11 && node.expression &&
3002 isWrappedBuilderCallExpression(node.expression as ts.CallExpression)) {
3008 function judgeBuilderType(node: ts.ExpressionStatement): boolean {
3015 if (node.expression && node.expression.expression && checker) {
3016 const type: ts.Type = checker.getTypeAtLocation(node.expression.expression);
3032 function getEtsComponentExpression(node:ts.ExpressionStatement): ts.EtsComponentExpression {
3033 let current: any = node.expression;
3043 function checkEtsAndIdInIf(node:ts.ExpressionStatement, parent: string): [ts.EtsComponentExpression…
3044 let current: any = node.expression;
3060 function checkIdInIf(node:ts.ExpressionStatement, parent: string): ts.Expression {
3061 let current: any = node.expression;
3075 function checkEtsComponent(node: ts.ExpressionStatement, log: LogInfo[]): void {
3076 const etsComponentExpression: ts.EtsComponentExpression = getEtsComponentExpression(node);
3087 function checkButtonParamHasLabel(node: ts.EtsComponentExpression, log: LogInfo[]): void {
3088 if (node.arguments && node.arguments.length !== 0) {
3089 for (let i = 0; i < node.arguments.length; i++) {
3090 let argument: ts.Expression = node.arguments[i];
3096 pos: node.getStart()
3104 function isLazyForEachChild(node: ts.ExpressionStatement): boolean {
3105 let temp: any = node.parent;
3136 export function createFunction(node: ts.Identifier, attrNode: ts.Identifier,
3139 const compName: string = node.escapedText.toString();
3145 if (checkCreateArgumentBuilder(node, attrNode)) {
3156 node,
3164 node,
3172 function checkCreateArgumentBuilder(node: ts.Identifier, attrNode: ts.Identifier): boolean {
3174 CREATE_BIND_COMPONENT.has(node.escapedText.toString())) {
3197 function checkNonspecificParents(node: ts.ExpressionStatement, name: string, savedParent: string, l…
3206 pos: node.expression.getStart()