Lines Matching refs:ts
16 import ts from 'typescript';
143 export function processComponentClass(node: ts.StructDeclaration, context: ts.TransformationContext,
144 log: LogInfo[], program: ts.Program): ts.ClassDeclaration {
145 const decoratorNode: readonly ts.Decorator[] = ts.getAllDecorators(node); constant
146 const memberNode: ts.ClassElement[] =
148 return ts.factory.createClassDeclaration(ts.getModifiers(node), node.name,
152 function checkPreview(node: ts.StructDeclaration): boolean {
154 const decorators: readonly ts.Decorator[] = ts.getAllDecorators(node); constant
171 componentFreezeParam: ts.Expression;
173 function processMembers(members: ts.NodeArray<ts.ClassElement>, parentComponentName: ts.Identifier,
174 context: ts.TransformationContext, decoratorNode: readonly ts.Decorator[], log: LogInfo[],
175 program: ts.Program, hasPreview: boolean): ts.ClassElement[] {
178 const newMembers: ts.ClassElement[] = [];
179 const watchMap: Map<string, ts.Node> = new Map();
180 const updateParamsStatements: ts.Statement[] = [];
181 const stateVarsStatements: ts.Statement[] = [];
182 const purgeVariableDepStatements: ts.Statement[] = [];
183 const rerenderStatements: ts.Statement[] = [];
184 const deleteParamsStatements: ts.PropertyDeclaration[] = [];
187 const interfaceNode = ts.factory.createInterfaceDeclaration(undefined,
189 members.forEach((item: ts.ClassElement) => {
190 let updateItem: ts.ClassElement;
191 if (ts.isPropertyDeclaration(item)) {
228 if (ts.isMethodDeclaration(item) && item.name) {
262 function decoratorAssignParams(decoratorNode: readonly ts.Decorator[], context: ts.TransformationCo…
265 return decoratorNode.some((item: ts.Decorator) => {
277 function isFreezeComponents(decorator: ts.Decorator, context: ts.TransformationContext,
280 ts.visitNode(decorator, visitComponentParament);
281 function visitComponentParament(decorator: ts.Node): ts.Node {
282 if (ts.isPropertyAssignment(decorator) && decorator.name && decorator.name.text &&
288 return ts.visitEachChild(decorator, visitComponentParament, context);
293 function getEntryNameFunction(entryName: string): ts.MethodDeclaration {
294 return ts.factory.createMethodDeclaration(
295 [ts.factory.createToken(ts.SyntaxKind.StaticKeyword)],
297 ts.factory.createIdentifier(GET_ENTRYNAME),
301 ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
302 ts.factory.createBlock(
303 [ts.factory.createReturnStatement(ts.factory.createStringLiteral(entryName))],
309 function assignParams(parentComponentName: string): ts.Statement[] {
310 return [ts.factory.createIfStatement(
311 ts.factory.createBinaryExpression(
312 … ts.factory.createTypeOfExpression(ts.factory.createIdentifier(COMPONENT_PARAMS_LAMBDA_FUNCTION)),
313 ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken),
314 ts.factory.createStringLiteral(FUNCTION)
316 ts.factory.createBlock(
317 [ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(
318 ts.factory.createPropertyAccessExpression(
319 ts.factory.createThis(),
320 ts.factory.createIdentifier(COMPONENT_PARAMS_FUNCTION)
322 ts.factory.createToken(ts.SyntaxKind.EqualsToken),
323 ts.factory.createIdentifier(COMPONENT_PARAMS_LAMBDA_FUNCTION)
330 function decoratorComponentParam(freezeParam: FreezeParamType): ts.IfStatement[] {
331 return [ts.factory.createIfStatement(
332 ts.factory.createBinaryExpression(
333 ts.factory.createElementAccessExpression(
334 ts.factory.createSuper(),
335 ts.factory.createStringLiteral(INIT_ALLOW_COMPONENT_FREEZE)
337 ts.factory.createToken(ts.SyntaxKind.AmpersandAmpersandToken),
338 ts.factory.createBinaryExpression(
339 ts.factory.createTypeOfExpression(ts.factory.createElementAccessExpression(
340 ts.factory.createSuper(),
341 ts.factory.createStringLiteral(INIT_ALLOW_COMPONENT_FREEZE)
343 ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken),
344 ts.factory.createStringLiteral(FUNCTION)
347 ts.factory.createBlock(
348 [ts.factory.createExpressionStatement(ts.factory.createCallExpression(
349 ts.factory.createElementAccessExpression(
350 ts.factory.createSuper(),
351 ts.factory.createStringLiteral(INIT_ALLOW_COMPONENT_FREEZE)
362 function isStaticProperty(property: ts.PropertyDeclaration): boolean {
363 const modifiers: readonly ts.Modifier[] = constant
364 ts.canHaveModifiers(property) ? ts.getModifiers(property) : undefined;
366 return modifier.kind === ts.SyntaxKind.StaticKeyword;
370 function validateDecorators(item: ts.ClassElement, log: LogInfo[]): void {
371 const decorators: readonly ts.Decorator[] = ts.getAllDecorators(item); constant
373 decorators.map((decorator: ts.Decorator) => {
388 purgeVariableDepStatements: ts.Statement[]
398 newMembers: ts.ClassElement[],
399 parentComponentName: ts.Identifier,
400 updateParamsStatements: ts.Statement[],
401 purgeVariableDepStatements: ts.Statement[],
402 rerenderStatements: ts.Statement[],
403 stateVarsStatements: ts.Statement[]
417 function addPropertyMember(item: ts.ClassElement, newMembers: ts.ClassElement[],
418 program: ts.Program, parentComponentName: string, log: LogInfo[]): void {
419 const propertyItem: ts.PropertyDeclaration = item as ts.PropertyDeclaration;
421 let updatePropertyItem: ts.PropertyDeclaration;
422 const type: ts.TypeNode = propertyItem.type;
423 const decorators: readonly ts.Decorator[] = ts.getAllDecorators(propertyItem); constant
429 let newType: ts.TypeNode;
458 function createPropertyDeclaration(propertyItem: ts.PropertyDeclaration, newType: ts.TypeNode | und…
459 …normalVar: boolean, isLocalStorage: boolean = false, parentComponentName: string = null): ts.Prope…
467 const privateM: ts.ModifierToken<ts.SyntaxKind.PrivateKeyword> =
468 ts.factory.createModifier(ts.SyntaxKind.PrivateKeyword);
469 const modifiers: readonly ts.Modifier[] = constant
470 ts.canHaveModifiers(propertyItem) ? ts.getModifiers(propertyItem) : undefined;
471 return ts.factory.updatePropertyDeclaration(propertyItem,
472 …ts.concatenateDecoratorsAndModifiers(undefined, modifiers || [privateM]), prefix + propertyItem.na…
478 function createLocalStroageCallExpression(node: ts.PropertyDeclaration, name: string,
479 parentComponentName: string): ts.CallExpression {
480 const decorators: readonly ts.Decorator[] = ts.getAllDecorators(node); constant
487 const localValue: ts.Expression[] = [
489 …node.initializer ? node.initializer : ts.factory.createNumericLiteral(COMPONENT_CONSTRUCTOR_UNDEFI…
490 ts.factory.createThis(),
491 ts.factory.createStringLiteral(name || COMPONENT_CONSTRUCTOR_UNDEFINED)
501 return ts.factory.createCallExpression(
502 ts.factory.createPropertyAccessExpression(
504 ts.factory.createPropertyAccessExpression(
505 ts.factory.createThis(),
506 ts.factory.createIdentifier(`${COMPONENT_CONSTRUCTOR_LOCALSTORAGE}_`)
507 ) : ts.factory.createThis(),
508 ts.factory.createIdentifier(localFuncName)
516 function processComponentMethod(node: ts.MethodDeclaration, parentComponentName: ts.Identifier,
517 context: ts.TransformationContext, log: LogInfo[], buildCount: BuildCount): ts.MethodDeclaration {
518 let updateItem: ts.MethodDeclaration = node;
520 const customBuilder: ts.Decorator[] = [];
538 const buildNode: ts.MethodDeclaration = processComponentBuild(node, log);
540 } else if (node.body && ts.isBlock(node.body)) {
542 updateItem = ts.factory.updateMethodDeclaration(node, ts.getModifiers(node),
551 …const parameters: ts.NodeArray<ts.ParameterDeclaration> = ts.factory.createNodeArray(Array.from(no…
556 const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined;
557 const builderNode: ts.MethodDeclaration = ts.factory.updateMethodDeclaration(node,
558 …ts.concatenateDecoratorsAndModifiers(customBuilder, modifiers), node.asteriskToken, node.name, nod…
565 if (ts.isBlock(node.body) && node.body.statements && node.body.statements.length) {
584 export function createParentParameter(): ts.ParameterDeclaration {
585 return ts.factory.createParameterDeclaration(undefined, undefined,
586 ts.factory.createIdentifier(COMPONENT_CONSTRUCTOR_PARENT), undefined, undefined,
587 ts.factory.createIdentifier(NULL));
590 export function processBuildMember(node: ts.MethodDeclaration | ts.FunctionDeclaration, context: ts…
591 log: LogInfo[], isBuilder = false): ts.MethodDeclaration | ts.FunctionDeclaration {
592 return ts.visitNode(node, visitBuild);
593 function visitBuild(node: ts.Node): ts.Node {
595 node = processGeometryView(node as ts.ExpressionStatement, log);
598 node = createReference(node as ts.PropertyAssignment, log, isBuilder);
600 if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name) &&
601 …stateObjectCollection.has(checkStateName(node)) && node.parent && ts.isCallExpression(node.parent)…
602 ts.isPropertyAccessExpression(node.parent.expression) && node !== node.parent.expression &&
604 return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(
605 ts.factory.createIdentifier(FOREACH_OBSERVED_OBJECT),
606 ts.factory.createIdentifier(FOREACH_GET_RAW_OBJECT)), undefined, [node]);
608 return ts.visitEachChild(node, visitBuild, context);
610 function checkStateName(node: ts.PropertyAccessExpression): string {
611 if (node.expression && !node.expression.expression && node.name && ts.isIdentifier(node.name)) {
618 function isGeometryView(node: ts.Node): boolean {
619 if (ts.isExpressionStatement(node) && ts.isCallExpression(node.expression)) {
620 const call: ts.CallExpression = node.expression;
621 const exp: ts.Expression = call.expression;
622 const args: ts.NodeArray<ts.Expression> = call.arguments;
623 if (ts.isPropertyAccessExpression(exp) && ts.isIdentifier(exp.expression) &&
624 exp.expression.escapedText.toString() === GEOMETRY_VIEW && ts.isIdentifier(exp.name) &&
626 (ts.isArrowFunction(args[0]) || ts.isFunctionExpression(args[0]))) {
633 function processGeometryView(node: ts.ExpressionStatement,
634 log: LogInfo[]): ts.ExpressionStatement {
635 const exp: ts.CallExpression = node.expression as ts.CallExpression;
636 const arg: ts.ArrowFunction | ts.FunctionExpression =
637 exp.arguments[0] as ts.ArrowFunction | ts.FunctionExpression;
638 return ts.factory.updateExpressionStatement(node, ts.factory.updateCallExpression(exp,
639 exp.expression, undefined, [ts.factory.createArrowFunction(undefined, undefined, arg.parameters,
640 undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
644 function getGeometryReaderFunctionBlock(node: ts.ArrowFunction | ts.FunctionExpression,
645 log: LogInfo[]): ts.Block {
646 let blockNode: ts.Block;
647 if (ts.isBlock(node.body)) {
649 } else if (ts.isArrowFunction(node) && ts.isCallExpression(node.body)) {
650 blockNode = ts.factory.createBlock([ts.factory.createExpressionStatement(node.body)]);
655 function updateHeritageClauses(node: ts.StructDeclaration, log: LogInfo[])
656 : ts.NodeArray<ts.HeritageClause> {
664 const result: ts.HeritageClause[] = [];
665 const heritageClause: ts.HeritageClause = createHeritageClause();
667 return ts.factory.createNodeArray(result);
670 function checkHeritageClauses(node: ts.StructDeclaration): boolean {
673 const expressionNode: ts.ExpressionWithTypeArguments = node.heritageClauses[0].types[0];
674 if (expressionNode.expression && ts.isIdentifier(expressionNode.expression) &&
682 export function isProperty(node: ts.Node): Boolean {
684 if (node.parent.parent.expression && ts.isIdentifier(node.parent.parent.expression) &&
689 } else if (ts.isPropertyAccessExpression(node.parent.parent.expression) &&
690 ts.isIdentifier(node.parent.parent.expression.expression) &&
699 function judgmentParentType(node: ts.Node): boolean {
700 return ts.isPropertyAssignment(node) && node.name && ts.isIdentifier(node.name) &&
701 node.parent && ts.isObjectLiteralExpression(node.parent) && node.parent.parent &&
702 (ts.isCallExpression(node.parent.parent) || ts.isEtsComponentExpression(node.parent.parent));
705 export function createReference(node: ts.PropertyAssignment, log: LogInfo[], isBuilder = false,
706 isParamsLambda: boolean = false, isRecycleComponent: boolean = false): ts.PropertyAssignment {
708 const propertyName: ts.Identifier = node.name as ts.Identifier;
711 if (isRecycleComponent && ts.isShorthandPropertyAssignment(node)) {
714 const initExpression: ts.Expression = node.initializer;
716 if (ts.isIdentifier(initExpression) &&
719 } else if (ts.isPropertyAccessExpression(initExpression) && initExpression.expression &&
720 initExpression.expression.kind === ts.SyntaxKind.ThisKeyword &&
721 …ts.isIdentifier(initExpression.name) && initExpression.name.escapedText.toString().match(LINK_REG)…
723 …} else if (isBuilder && ts.isPropertyAccessExpression(initExpression) && initExpression.expression…
724 …ts.isIdentifier(initExpression.expression) && initExpression.expression.escapedText.toString() ===…
725 …ts.isIdentifier(initExpression.name) && linkParentComponent.includes(propertyName.escapedText.toSt…
738 function isMatchInitExpression(initExpression: ts.Expression): boolean {
739 return ts.isPropertyAccessExpression(initExpression) &&
741 initExpression.expression.kind === ts.SyntaxKind.ThisKeyword &&
742 ts.isIdentifier(initExpression.name);
745 function addDoubleUnderline(node: ts.PropertyAssignment, propertyName: ts.Identifier,
746 …initText: string, is$$ = false, isParamsLambda: boolean, isRecycleComponent: boolean): ts.Property…
747 return ts.factory.updatePropertyAssignment(node, propertyName,
748 ts.factory.createPropertyAccessExpression(
749 …is$$ && partialUpdateConfig.partialUpdateMode ? ts.factory.createIdentifier($$) : ts.factory.creat…
750 …isParamsLambda || isRecycleComponent ? ts.factory.createIdentifier(initText) : ts.factory.createId…
753 function getParentNode(node: ts.PropertyAssignment, collection: Map<string, Set<string>>): string[]…
754 const grandparentNode: ts.NewExpression = node.parent.parent as ts.NewExpression;
755 const grandparentExpression: ts.Identifier | ts.PropertyAccessExpression =
756 grandparentNode.expression as ts.Identifier | ts.PropertyAccessExpression;
759 if (ts.isIdentifier(grandparentExpression)) {
762 } else if (ts.isPropertyAccessExpression(grandparentExpression)) {
774 function addUpdateParamsFunc(statements: ts.Statement[], parentComponentName: ts.Identifier):
775 ts.MethodDeclaration {
779 function addInitialParamsFunc(statements: ts.Statement[], parentComponentName: ts.Identifier): ts.M…
783 function addUpdateStateVarsFunc(statements: ts.Statement[], parentComponentName: ts.Identifier): ts…
787 function addPurgeVariableDepFunc(statements: ts.Statement[]): ts.MethodDeclaration {
788 return ts.factory.createMethodDeclaration(
790 ts.factory.createIdentifier(COMPONENT_CONSTRUCTOR_PURGE_VARIABLE_DEP),
791 undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined,
792 ts.factory.createIdentifier(RMELMTID), undefined, undefined, undefined)], undefined,
793 ts.factory.createBlock(statements, true));
796 function addDeleteParamsFunc(statements: ts.PropertyDeclaration[],
797 updateRecyle: boolean = false): ts.MethodDeclaration {
798 const deleteStatements: ts.ExpressionStatement[] = [];
799 const updateStatements: ts.ExpressionStatement[] = [];
800 statements.forEach((statement: ts.PropertyDeclaration) => {
801 const name: ts.Identifier = statement.name as ts.Identifier;
802 let paramsStatement: ts.ExpressionStatement;
803 const decorators: readonly ts.Decorator[] = ts.getAllDecorators(statement); constant
815 const defaultStatement: ts.ExpressionStatement =
816 ts.factory.createExpressionStatement(ts.factory.createCallExpression(
817 ts.factory.createPropertyAccessExpression(
818 ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(
819 ts.factory.createIdentifier(CREATE_CONSTRUCTOR_SUBSCRIBER_MANAGER),
820 ts.factory.createIdentifier(CREATE_CONSTRUCTOR_GET_FUNCTION)), undefined, []),
821 ts.factory.createIdentifier(CREATE_CONSTRUCTOR_DELETE_FUNCTION)),
822 undefined, [ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(
823 ts.factory.createThis(), ts.factory.createIdentifier(
829 …const aboutToBeDeletedInternalStatement: ts.ExpressionStatement = createDeletedInternalStatement();
832 const deleteParamsMethod: ts.MethodDeclaration =
837 function createRecycleElmt(statements: ts.Statement[]): ts.MethodDeclaration {
838 return ts.factory.createMethodDeclaration(undefined, undefined,
839 ts.factory.createIdentifier(UPDATE_RECYCLE_ELMT_ID), undefined, undefined, [
840 ts.factory.createParameterDeclaration(undefined, undefined,
841 ts.factory.createIdentifier(OLD_ELMT_ID)),
842 ts.factory.createParameterDeclaration(undefined, undefined,
843 ts.factory.createIdentifier(NEW_ELMT_ID))
844 ], undefined, ts.factory.createBlock(statements, true));
847 function createParamsWithUnderlineStatement(name: ts.Identifier): ts.ExpressionStatement {
848 return ts.factory.createExpressionStatement(
849 ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(
850 ts.factory.createPropertyAccessExpression(ts.factory.createThis(),
851 ts.factory.createIdentifier(`__${name.escapedText.toString()}`)),
852 ts.factory.createIdentifier(COMPONENT_CONSTRUCTOR_DELETE_PARAMS)), undefined, []));
855 function createElmtIdWithUnderlineStatement(name: ts.Identifier): ts.ExpressionStatement {
856 return ts.factory.createExpressionStatement(
857 ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(
858 ts.factory.createPropertyAccessExpression(ts.factory.createThis(),
859 ts.factory.createIdentifier(`__${name.escapedText.toString()}`)),
860 ts.factory.createIdentifier(COMPONENT_UPDATE_ELMT_ID)), undefined, [
861 ts.factory.createIdentifier(OLD_ELMT_ID), ts.factory.createIdentifier(NEW_ELMT_ID)
865 function createDeletedInternalStatement(): ts.ExpressionStatement {
866 return ts.factory.createExpressionStatement(ts.factory.createCallExpression(
867 ts.factory.createPropertyAccessExpression(ts.factory.createThis(),
868 ts.factory.createIdentifier(ABOUTTOBEDELETEDINTERNAL)), undefined, []));
871 function addRerenderFunc(statements: ts.Statement[]): ts.MethodDeclaration {
872 const updateDirtyElementStatement: ts.Statement = ts.factory.createExpressionStatement(
873 ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(
874 ts.factory.createThis(), ts.factory.createIdentifier(UPDATEDIRTYELEMENTS)), undefined, []));
876 return ts.factory.createMethodDeclaration(undefined, undefined,
877 ts.factory.createIdentifier(COMPONENT_RERENDER_FUNCTION), undefined, undefined, [], undefined,
878 ts.factory.createBlock(statements, true));
881 function createParamsInitBlock(express: string, statements: ts.Statement[],
882 parentComponentName?: ts.Identifier): ts.MethodDeclaration {
883 const methodDeclaration: ts.MethodDeclaration = ts.factory.createMethodDeclaration(
884 undefined, undefined, ts.factory.createIdentifier(express), undefined, undefined,
885 [ts.factory.createParameterDeclaration(undefined, undefined,
887 ts.factory.createIdentifier(CREATE_CONSTRUCTOR_PARAMS), undefined,
889 ts.factory.createTypeReferenceNode(
890 … ts.factory.createIdentifier(parentComponentName.getText() + INTERFACE_NAME_SUFFIX), undefined),
891 undefined)], undefined, ts.factory.createBlock(statements, true));
895 function validateBuildMethodCount(buildCount: BuildCount, parentComponentName: ts.Identifier,
906 function validateHasController(componentName: ts.Identifier, checkController: ControllerType,
917 function createHeritageClause(): ts.HeritageClause {
919 return ts.factory.createHeritageClause(
920 ts.SyntaxKind.ExtendsKeyword,
921 …[ts.factory.createExpressionWithTypeArguments(ts.factory.createIdentifier(BASE_COMPONENT_NAME_PU),…
924 return ts.factory.createHeritageClause(
925 ts.SyntaxKind.ExtendsKeyword,
926 …[ts.factory.createExpressionWithTypeArguments(ts.factory.createIdentifier(BASE_COMPONENT_NAME), []…
930 function createTypeReference(decoratorName: string, type: ts.TypeNode, log: LogInfo[],
931 program: ts.Program): ts.TypeNode {
932 let newType: ts.TypeNode;
936 newType = ts.factory.createTypeReferenceNode(
940 [type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
945 newType = ts.factory.createTypeReferenceNode(
949 [type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
953 newType = ts.factory.createTypeReferenceNode(
955 [type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
959 newType = ts.factory.createTypeReferenceNode(
961 [type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
966 newType = ts.factory.createTypeReferenceNode(OBSERVED_PROPERTY_ABSTRACT, [
967 type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
972 newType = ts.factory.createTypeReferenceNode(OBSERVED_PROPERTY_ABSTRACT, [
973 type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
980 function createTypeReferencePU(decoratorName: string, type: ts.TypeNode, log: LogInfo[],
981 program: ts.Program): ts.TypeNode {
982 let newType: ts.TypeNode;
986 newType = ts.factory.createTypeReferenceNode(
990 [type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
994 newType = ts.factory.createTypeReferenceNode(
998 [type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
1002 newType = ts.factory.createTypeReferenceNode(
1004 [type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
1008 newType = ts.factory.createTypeReferenceNode(
1010 [type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
1016 newType = ts.factory.createTypeReferenceNode(OBSERVED_PROPERTY_ABSTRACT_PU, [
1017 type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)
1022 newType = ts.factory.createTypeReferenceNode(OBSERVED_PROPERTY_ABSTRACT_PU, [
1023 type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)