Global Function of coref.javascript.gdl

isExternalModuleReference 

/**
* Determines whether a node is an external module reference.
*/
  • Parameter node: Node
  • Return bool
pub fn isExternalModuleReference(node: Node) -> bool;

isExportSpecifier 

/**
* Determines whether a node is an export specifier.
*/
  • Parameter node: Node
  • Return bool
pub fn isExportSpecifier(node: Node) -> bool;

isNamespaceExport 

/**
* Determines whether a node is a namespace export.
*/
  • Parameter node: Node
  • Return bool
pub fn isNamespaceExport(node: Node) -> bool;

isNamedExports 

/**
* Determines whether a node is a named exports.
*/
  • Parameter node: Node
  • Return bool
pub fn isNamedExports(node: Node) -> bool;

isNamedImports 

/**
* Determines whether a node is a named imports.
*/
  • Parameter node: Node
  • Return bool
pub fn isNamedImports(node: Node) -> bool;

isNamespaceImport 

/**
* Determines whether a node is a namespace import.
*/
  • Parameter node: Node
  • Return bool
pub fn isNamespaceImport(node: Node) -> bool;

syntaxKind 

/**
* The predict for the value and name pairs of SyntaxKinds
*/
  • Parameter kind: int
  • Parameter name: string
  • Return bool
pub fn syntaxKind(kind: int, name: string) -> bool;

isOverrideKeyword 

/**
* Determines whether a node is an `override` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isOverrideKeyword(node: Node) -> bool;

isReadonlyKeyword 

/**
* Determines whether a node is a `readonly` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isReadonlyKeyword(node: Node) -> bool;

isDeclareKeyword 

/**
* Determines whether a node is a `declare` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isDeclareKeyword(node: Node) -> bool;

isAbstractKeyword 

/**
* Determines whether a node is an `abstract` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isAbstractKeyword(node: Node) -> bool;

isStaticKeyword 

/**
* Determines whether a node is a `static` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isStaticKeyword(node: Node) -> bool;

isPublicKeyword 

/**
* Determines whether a node is a `public` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isPublicKeyword(node: Node) -> bool;

isExportKeyword 

/**
* Determines whether a node is an `export` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isExportKeyword(node: Node) -> bool;

isDefaultKeyword 

/**
* Determines whether a node is a `default` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isDefaultKeyword(node: Node) -> bool;

isConstKeyword 

/**
* Determines whether a node is a `const` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isConstKeyword(node: Node) -> bool;

isTokenKind 

/**
* Determines whether a node kind is a token kind.
*/
  • Parameter kind: int
  • Return bool
pub fn isTokenKind(kind: int) -> bool;

isAssignmentOperator 

/**
* Determines whether a node is a simple assignment operator `=` or a compound
* assignment operator.
*/
  • Parameter node: Node
  • Return bool
pub fn isAssignmentOperator(node: Node) -> bool;

isBinaryBitwiseOperator 

/**
* Determines whether a node is a binary bitwise operator `&`, `|` or `^`.
*/
  • Parameter node: Node
  • Return bool
pub fn isBinaryBitwiseOperator(node: Node) -> bool;

isEqualityOperatorOrHigher 

/**
* Determines whether a node is an equality operator or higher.
*/
  • Parameter node: Node
  • Return bool
pub fn isEqualityOperatorOrHigher(node: Node) -> bool;

isEqualityOperator 

/**
* Determines whether a node is an equality operator `==`, `!=`, `===` or `!==`.
*/
  • Parameter node: Node
  • Return bool
pub fn isEqualityOperator(node: Node) -> bool;

isRelationalOperatorOrHigher 

/**
* Determines whether a node is a relational operator or higher.
*/
  • Parameter node: Node
  • Return bool
pub fn isRelationalOperatorOrHigher(node: Node) -> bool;

isRelationalOperator 

/**
* Determines whether a node is a relational operator `<`, `<=`, `>`, `>=`, `instanceof` or `in`.
*/
  • Parameter node: Node
  • Return bool
pub fn isRelationalOperator(node: Node) -> bool;

isAssignmentOperatorOrHigher 

/**
* Determines whether a node is an assignment operator or higher.
*/
  • Parameter node: Node
  • Return bool
pub fn isAssignmentOperatorOrHigher(node: Node) -> bool;

isShiftOperatorOrHigher 

/**
* Determines whether a node is a shift operator or higher.
*/
  • Parameter node: Node
  • Return bool
pub fn isShiftOperatorOrHigher(node: Node) -> bool;

isAdditiveOperatorOrHigher 

/**
* Determines whether a node is an additive operator or higher.
*/
  • Parameter node: Node
  • Return bool
pub fn isAdditiveOperatorOrHigher(node: Node) -> bool;

isAdditiveOperator 

/**
* Determines whether a node is an additive operator `+` or `-`.
*/
  • Parameter node: Node
  • Return bool
pub fn isAdditiveOperator(node: Node) -> bool;

isMultiplicativeOperatorOrHigher 

/**
* Determines whether a node is a multiplicative operator or higher.
*/
  • Parameter node: Node
  • Return bool
pub fn isMultiplicativeOperatorOrHigher(node: Node) -> bool;

isStrictEqualityExpression 

/**
* Determines whether a node is a strict equality expression using `===`.
*/
  • Parameter node: Node
  • Return bool
pub fn isStrictEqualityExpression(node: Node) -> bool;

isIdentifier 

/**
* Determines whether a node is an identifier.
*/
  • Parameter node: Node
  • Return bool
pub fn isIdentifier(node: Node) -> bool;

isSymbolKeyword 

/**
* Determines whether a node is a `symbol` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isSymbolKeyword(node: Node) -> bool;

isEqualityExpression 

/**
* Determines whether a node is an equality expression using `==`.
*/
  • Parameter node: Node
  • Return bool
pub fn isEqualityExpression(node: Node) -> bool;

isImportSpecifier 

/**
* Determines whether a node is an import specifier.
*/
  • Parameter node: Node
  • Return bool
pub fn isImportSpecifier(node: Node) -> bool;

isBitwiseAndAssignmentExpression 

/**
* Determines whether a node is a bitwise AND assignment expression using `&=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isBitwiseAndAssignmentExpression(node: Node) -> bool;

isEqualityTestExpression 

/**
* Determines whether a node is an equality test expression using `==`, `!=`,
* `===` or `!==`.
*/
  • Parameter node: Node
  • Return bool
pub fn isEqualityTestExpression(node: Node) -> bool;

isInstanceOfExpression 

/**
* Determines whether a node is an `instanceof` expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isInstanceOfExpression(node: Node) -> bool;

isReturnStatement 

/**
* Determines whether a node is a `return` statement
*/
  • Parameter node: Node
  • Return bool
pub fn isReturnStatement(node: Node) -> bool;

isGreaterThanExpression 

/**
* Determines whether a node is a greater-than expression using `>`.
*/
  • Parameter node: Node
  • Return bool
pub fn isGreaterThanExpression(node: Node) -> bool;

isSubtractionExpression 

/**
* Determines whether a node is a subtraction expression using `-`.
*/
  • Parameter node: Node
  • Return bool
pub fn isSubtractionExpression(node: Node) -> bool;

isAdditionExpression 

/**
* Determines whether a node is an addition expression using `+`.
*/
  • Parameter node: Node
  • Return bool
pub fn isAdditionExpression(node: Node) -> bool;

isDivisionExpression 

/**
* Determines whether a node is a division expression using `/`.
*/
  • Parameter node: Node
  • Return bool
pub fn isDivisionExpression(node: Node) -> bool;

isExponentiationExpression 

/**
* Determines whether a node is a exponentiation expression using `**`.
*/
  • Parameter node: Node
  • Return bool
pub fn isExponentiationExpression(node: Node) -> bool;

isRemainderExpression 

/**
* Determines whether a node is a remainder expression using `%`.
*/
  • Parameter node: Node
  • Return bool
pub fn isRemainderExpression(node: Node) -> bool;

isCommaListExpression 

/**
* Determines whether a node is a comma list expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isCommaListExpression(node: Node) -> bool;

isExpression 

/**
* Determines whether a node is an expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isExpression(node: Node) -> bool;

isSpreadElement 

/**
* Determines whether a node is a spread element.
*/
  • Parameter node: Node
  • Return bool
pub fn isSpreadElement(node: Node) -> bool;

isPostfixUnaryExpression 

/**
* Determines whether a node is a postfix unary expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isPostfixUnaryExpression(node: Node) -> bool;

isPrefixUnaryExpression 

/**
* Determines whether a node is a prefix unary expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isPrefixUnaryExpression(node: Node) -> bool;

isDeleteExpression 

/**
* Determines whether a node is a `delete` expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isDeleteExpression(node: Node) -> bool;

isAsteriskAsteriskEqualsToken 

/**
* Determines whether a node is an `**=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isAsteriskAsteriskEqualsToken(node: Node) -> bool;

isAwaitExpression 

/**
* Determines whether a node is an `await` expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isAwaitExpression(node: Node) -> bool;

isFunctionExpression 

/**
* Determines whether a node is a function expression
*/
  • Parameter node: Node
  • Return bool
pub fn isFunctionExpression(node: Node) -> bool;

isParenthesizedExpression 

/**
* Determines whether a node is a parenthesized expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isParenthesizedExpression(node: Node) -> bool;

isControlNode 

/**
* Determines whether a node is a control Node
*/
  • Parameter node: Node
  • Return bool
pub fn isControlNode(node: Node) -> bool;

isElementAccessExpression 

/**
* Determines whether a node is an element access expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isElementAccessExpression(node: Node) -> bool;

isObjectLiteralExpression 

/**
* Determines whether a node is an object literal expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isObjectLiteralExpression(node: Node) -> bool;

isTaggedTemplateExpression 

/**
* Determines whether a node is a tagged template expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isTaggedTemplateExpression(node: Node) -> bool;

isTypePredicate 

/**
* Determines whether a node is a type predicate.
*/
  • Parameter node: Node
  • Return bool
pub fn isTypePredicate(node: Node) -> bool;

isUndefinedKeyword 

/**
* Determines whether a node is an `undefined` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isUndefinedKeyword(node: Node) -> bool;

isOmittedExpression 

/**
* Determines whether a node is an omitted expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isOmittedExpression(node: Node) -> bool;

isJsxOpeningFragment 

/**
* Determines whether a node is a JSX opening fragment.
*/
  • Parameter node: Node
  • Return bool
pub fn isJsxOpeningFragment(node: Node) -> bool;

isAdditiveExpression 

/**
* Determines whether a node is an additive expression using `+` or `-`.
*/
  • Parameter node: Node
  • Return bool
pub fn isAdditiveExpression(node: Node) -> bool;

defLValue 

/**
* The relation of definitions and lvalues
*/

pub fn defLValue(def: ControlFlowNode, lValue: RefExpr) -> bool;

isCallExpression 

/**
* Determines whether a node is a call expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isCallExpression(node: Node) -> bool;

isBinaryBitwiseOperatorOrHigher 

/**
* Determines whether a node is a binary bitwise operator or higher.
*/
  • Parameter node: Node
  • Return bool
pub fn isBinaryBitwiseOperatorOrHigher(node: Node) -> bool;

isTildeToken 

/**
* Determines whether a node is a `~` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isTildeToken(node: Node) -> bool;

isMetaProperty 

/**
* Determines whether a node is a meta property.
*/
  • Parameter node: Node
  • Return bool
pub fn isMetaProperty(node: Node) -> bool;

isIntersectionType 

/**
* Determines whether a node is an intersection type.
*/
  • Parameter node: Node
  • Return bool
pub fn isIntersectionType(node: Node) -> bool;

isAsExpression 

/**
* Determines whether a node is an `as` expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isAsExpression(node: Node) -> bool;

killedByBBWithKiller 

/**
* Gets the killers in BB that kill the given lvalue, with BB index.
*/

pub fn killedByBBWithKiller(bb: BasicBlock, lvalue: LValue, killer: LValue, index: int) -> bool;

isIterationStatement 

/**
* Determine whether a node is an iteration statement, including `while`, `do`-`while`,
* `for` and enhanced `for` (`for`-`in`, `for`-`of`) statements.
*/
  • Parameter node: Node
  • Return bool
pub fn isIterationStatement(node: Node) -> bool;

isUnsignedRightShiftExpression 

/**
* Determines whether a node is a unsigned right-shift expression using `>>>`.
*/
  • Parameter node: Node
  • Return bool
pub fn isUnsignedRightShiftExpression(node: Node) -> bool;

isThisExpression 

/**
* Determines whether a node is a `this` expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isThisExpression(node: Node) -> bool;

isTemplateTail 

/**
* Determines whether a node is a template tail.
*/
  • Parameter node: Node
  • Return bool
pub fn isTemplateTail(node: Node) -> bool;

isClassExpression 

/**
* Determines whether a node is a class expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isClassExpression(node: Node) -> bool;

isCommaToken 

/**
* Determines whether a node is a `,` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isCommaToken(node: Node) -> bool;

isThrowCompletion 

pub fn isThrowCompletion(c: Completion) -> bool;

isPrefixIncrementExpression 

/**
* Determines whether a node is a prefix increment expression using `++`.
*/
  • Parameter node: Node
  • Return bool
pub fn isPrefixIncrementExpression(node: Node) -> bool;

isImportClause 

/**
* Determines whether a node is an import clause.
*/
  • Parameter node: Node
  • Return bool
pub fn isImportClause(node: Node) -> bool;

isTemplateExpression 

/**
* Determines whether a node is a template expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isTemplateExpression(node: Node) -> bool;

isInExpression 

/**
* Determines whether a node is an `in` expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isInExpression(node: Node) -> bool;

isShiftExpression 

/**
* Determines whether a node is a shift expression using `<<`, `>>` or `>>>`.
*/
  • Parameter node: Node
  • Return bool
pub fn isShiftExpression(node: Node) -> bool;

isLeftShiftExpression 

/**
* Determines whether a node is a left-shift expression using `<<`.
*/
  • Parameter node: Node
  • Return bool
pub fn isLeftShiftExpression(node: Node) -> bool;

isNeverKeyword 

/**
* Determines whether a node is a `never` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isNeverKeyword(node: Node) -> bool;

isVariableStatement 

/**
* Determines whether a node is a variable statement
*/
  • Parameter node: Node
  • Return bool
pub fn isVariableStatement(node: Node) -> bool;

isQuestionQuestionToken 

/**
* Determines whether a node is a `??` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isQuestionQuestionToken(node: Node) -> bool;

isAmpersandAmpersandEqualsToken 

/**
* Determines whether a node is an `&&=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isAmpersandAmpersandEqualsToken(node: Node) -> bool;

isRightShiftExpression 

/**
* Determines whether a node is a signed right-shift expression using `>>`.
*/
  • Parameter node: Node
  • Return bool
pub fn isRightShiftExpression(node: Node) -> bool;

isTypeAliasDeclaration 

/**
* Determines whether a node is a type alias declaration.
*/
  • Parameter node: Node
  • Return bool
pub fn isTypeAliasDeclaration(node: Node) -> bool;

isTypeElement 

/**
* Determines whether a node is a type element.
*/
  • Parameter node: Node
  • Return bool
pub fn isTypeElement(node: Node) -> bool;

isThrowStatement 

/**
* Determines whether a node is a `throw` statement
*/
  • Parameter node: Node
  • Return bool
pub fn isThrowStatement(node: Node) -> bool;

isNullishCoalescingExpression 

/**
* Determines whether a node is a nullish coalescing expression using `??`.
*/
  • Parameter node: Node
  • Return bool
pub fn isNullishCoalescingExpression(node: Node) -> bool;

isBarEqualsToken 

/**
* Determines whether a node is a `|=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isBarEqualsToken(node: Node) -> bool;

isBarBarToken 

/**
* Determines whether a node is a `||` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isBarBarToken(node: Node) -> bool;

isPrimaryExpression 

/**
* Determines whether a node is a primary expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isPrimaryExpression(node: Node) -> bool;

isUpdateOperator 

/**
* Determines whether a node is an update operator.
*/
  • Parameter node: Node
  • Return bool
pub fn isUpdateOperator(node: Node) -> bool;

isSuperExpression 

/**
* Determines whether a node is a `super` expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isSuperExpression(node: Node) -> bool;

isFunctionLikeDeclaration 

/**
* Determines whether a node is a function-like declaration, including:
*  - MethodDeclaration,
*  - Constructor,
*  - GetAccessor,
*  - SetAccessor,
*  - FunctionExpression,
*  - ArrowFunction,
*  - FunctionDeclaration,
*/
  • Parameter node: Node
  • Return bool
pub fn isFunctionLikeDeclaration(node: Node) -> bool;

succ 

/**
* Gets the control flow successor node of a control flow node,
* and with the Completion information.
*/

pub fn succ(n: ControlFlowNode, c: Completion) -> *ControlFlowNode;

isBooleanKeyword 

/**
* Determines whether a node is a `boolean` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isBooleanKeyword(node: Node) -> bool;

first 

/**
* Get the node that should be visited first,
* selected from the node and it's descendants.
* Every control flow node must have and only have 1 first node.
*/

pub fn first(n: ControlFlowNode) -> ControlFlowNode;

isLogicalOrAssignmentExpression 

/**
* Determines whether a node is a logical OR assignment expression using `||=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isLogicalOrAssignmentExpression(node: Node) -> bool;

isLessThanExpression 

/**
* Determines whether a node is a less-than expression using `<`.
*/
  • Parameter node: Node
  • Return bool
pub fn isLessThanExpression(node: Node) -> bool;

continues 

/**
* If the body of loop finishes with completion,
* the loop will continue executing.
*/

pub fn continues(c: Completion, loop: IterationStatement) -> bool;

isFunctionLikeDeclarationKind 

/**
* Determines whether a node kind is a FunctionLikeDeclaration kind
*/
  • Parameter kind: int
  • Return bool
pub fn isFunctionLikeDeclarationKind(kind: int) -> bool;

mayThrow 

/**
* Determine whether a control flow node throws
* an exception.
*/

pub fn mayThrow(cfn: ControlFlowNode) -> bool;

isMethodDeclaration 

/**
* Determines whether a node is a MethodDeclaration
*/
  • Parameter node: Node
  • Return bool
pub fn isMethodDeclaration(node: Node) -> bool;

isTemplateLiteralLikeNode 

/**
* Determines whether a node is a template literal-like node, which is a no-substitution template literal, template head, template middle or template tail.
*/
  • Parameter node: Node
  • Return bool
pub fn isTemplateLiteralLikeNode(node: Node) -> bool;

isWithStatement 

/**
* Determines whether a node is a `with` statement
*/
  • Parameter node: Node
  • Return bool
pub fn isWithStatement(node: Node) -> bool;

isAsyncKeyword 

/**
* Determines whether a node is an `async` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isAsyncKeyword(node: Node) -> bool;

isSpreadAssignment 

/**
* Determines whether a node is a spread assignment.
*/
  • Parameter node: Node
  • Return bool
pub fn isSpreadAssignment(node: Node) -> bool;

isStrictInequalityExpression 

/**
* Determines whether a node is a strict inequality expression using `!==`.
*/
  • Parameter node: Node
  • Return bool
pub fn isStrictInequalityExpression(node: Node) -> bool;

isArrayLiteralExpression 

/**
* Determines whether a node is an array literal expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isArrayLiteralExpression(node: Node) -> bool;

isBreakStatement 

/**
* Determines whether a node is a `break` statement
*/
  • Parameter node: Node
  • Return bool
pub fn isBreakStatement(node: Node) -> bool;

isDebuggerStatement 

/**
* Determines whether a node is a `debugger` statement.
*/
  • Parameter node: Node
  • Return bool
pub fn isDebuggerStatement(node: Node) -> bool;

isImportExpression 

/**
* Determines whether a node is an `import` expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isImportExpression(node: Node) -> bool;

isForInitializer 

/**
* Determines whether a node is a initializer of for statement or enhanced for statement.
*/
  • Parameter node: Node
  • Return bool
pub fn isForInitializer(node: Node) -> bool;

isDoWhileStatement 

/**
* Determines whether a node is a `do`-`while` statement
*/
  • Parameter node: Node
  • Return bool
pub fn isDoWhileStatement(node: Node) -> bool;

isUnionType 

/**
* Determines whether a node is an union type.
*/
  • Parameter node: Node
  • Return bool
pub fn isUnionType(node: Node) -> bool;

isArrayType 

/**
* Determines whether a node is an array type.
*/
  • Parameter node: Node
  • Return bool
pub fn isArrayType(node: Node) -> bool;

isAsteriskToken 

/**
* Determines whether a node is a `*` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isAsteriskToken(node: Node) -> bool;

isPropertyAccessExpression 

/**
* Determines whether a node is a property access expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isPropertyAccessExpression(node: Node) -> bool;

isStatement 

/**
* Determines whether a node is a statement
*/
  • Parameter node: Node
  • Return bool
pub fn isStatement(node: Node) -> bool;

isBitwiseXorAssignmentExpression 

/**
* Determines whether a node is a bitwise XOR assignment expression using `^=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isBitwiseXorAssignmentExpression(node: Node) -> bool;

bbIDominates 

/**
* Hold if idomBB immediately dominates bb.
* idomBB is the closest strict dominator of bb, fit the following conditions:
* 1. idomBB strictly dominates bb
* 2. idomBB can't dominate any other bb's strict dominator
*/

pub fn bbIDominates(idomBB: BasicBlock, bb: BasicBlock) -> bool;

isDeclarationStatement 

/**
* Determines whether a node is a declaration statement
*/
  • Parameter node: Node
  • Return bool
pub fn isDeclarationStatement(node: Node) -> bool;

isTypeOperator 

/**
* Determines whether a node is a type operator.
*/
  • Parameter node: Node
  • Return bool
pub fn isTypeOperator(node: Node) -> bool;

isPostOrderNode 

/**
* Determine whether a control flow node is a post order node.
*/

pub fn isPostOrderNode(controlFlowNode: ControlFlowNode) -> bool;

isObjectLiteralElement 

/**
* Determines whether a node is an object literal element.
*/
  • Parameter node: Node
  • Return bool
pub fn isObjectLiteralElement(node: Node) -> bool;

isBinaryLogicalOperator 

/**
* Determines whether a node is a logical operator `&&`, `||` or `??`.
*/
  • Parameter node: Node
  • Return bool
pub fn isBinaryLogicalOperator(node: Node) -> bool;

isLogicalOrExpression 

/**
* Determines whether a node is a logical OR expression using `||`.
*/
  • Parameter node: Node
  • Return bool
pub fn isLogicalOrExpression(node: Node) -> bool;

isCatchClause 

/**
* Determines whether a node is an `catch` clause
*/
  • Parameter node: Node
  • Return bool
pub fn isCatchClause(node: Node) -> bool;

bbNotPostDominates 

/**
* Hold if npdomBB don't post dominates bb.
* the relation is same as not dominates relation but apply to Reverse-CFG.
*/

pub fn bbNotPostDominates(npdomBB: BasicBlock, bb: BasicBlock) -> bool;

isFunctionLike 

/**
* Determines whether a node is a FunctionLike
*/
  • Parameter node: Node
  • Return bool
pub fn isFunctionLike(node: Node) -> bool;

isStatementKindButNotDeclarationKind 

/**
* Determines whether a node kind is a statement kind, but not a declaration kind
*/
  • Parameter kind: int
  • Return bool
pub fn isStatementKindButNotDeclarationKind(kind: int) -> bool;

isDivisionAssignmentExpression 

/**
* Determines whether a node is a division assignment expression using `/=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isDivisionAssignmentExpression(node: Node) -> bool;

isAsteriskEqualsToken 

/**
* Determines whether a node is an `*=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isAsteriskEqualsToken(node: Node) -> bool;

isForStatement 

/**
* Determines whether a node is a `for` statement
*/
  • Parameter node: Node
  • Return bool
pub fn isForStatement(node: Node) -> bool;

isFunctionLikeKind 

/**
* Determines whether a node kind is a FunctionLike kind
*/
  • Parameter kind: int
  • Return bool
pub fn isFunctionLikeKind(kind: int) -> bool;

isBinaryOperator 

/**
* Determines whether a node is a binary operator.
*/
  • Parameter node: Node
  • Return bool
pub fn isBinaryOperator(node: Node) -> bool;

isModifier 

/**
* Determines whether a node is a modifier.
*/
  • Parameter node: Node
  • Return bool
pub fn isModifier(node: Node) -> bool;

isSetAccessor 

/**
* Determines whether a node is a `set` accessor
*/
  • Parameter node: Node
  • Return bool
pub fn isSetAccessor(node: Node) -> bool;

isLessThanLessThanToken 

/**
* Determines whether a node is a `<<` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isLessThanLessThanToken(node: Node) -> bool;

isRestType 

/**
* Determines whether a node is a rest type.
*/
  • Parameter node: Node
  • Return bool
pub fn isRestType(node: Node) -> bool;

isRemainderAssignmentExpression 

/**
* Determines whether a node is a remainder assignment expression using `%=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isRemainderAssignmentExpression(node: Node) -> bool;

isPostfixIncrementExpression 

/**
* Determines whether a node is a postfix increment expression using `++`.
*/
  • Parameter node: Node
  • Return bool
pub fn isPostfixIncrementExpression(node: Node) -> bool;

isRightShiftAssignmentExpression 

/**
* Determines whether a node is a right shift assignment expression using `>>=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isRightShiftAssignmentExpression(node: Node) -> bool;

isStrictEqualityTestExpression 

/**
* Determines whether a node is a strict equality test expression using
* `===` or `!==`.
*/
  • Parameter node: Node
  • Return bool
pub fn isStrictEqualityTestExpression(node: Node) -> bool;

isFunctionBlock 

/**
* Determines whether a node is a FunctionBlock
*/
  • Parameter node: Node
  • Return bool
pub fn isFunctionBlock(node: Node) -> bool;

isExportAssignment 

/**
* Determines whether a node is an export assignment.
*/
  • Parameter node: Node
  • Return bool
pub fn isExportAssignment(node: Node) -> bool;

isBitwiseAndExpression 

/**
* Determines whether a node is a bitwise AND expression using `&`.
*/
  • Parameter node: Node
  • Return bool
pub fn isBitwiseAndExpression(node: Node) -> bool;

isAwaitKeyword 

/**
* Determines whether a node is an `await` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isAwaitKeyword(node: Node) -> bool;

localFlowEdge 

pub fn localFlowEdge(predecessor: DataFlowNode, successor: DataFlowNode) -> bool;

isKeywordToken 

/**
* Determines whether a node is a keyword token.
*/
  • Parameter node: Node
  • Return bool
pub fn isKeywordToken(node: Node) -> bool;

isLeftShiftAssignmentExpression 

/**
* Determines whether a node is a left shift assignment expression using `<<=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isLeftShiftAssignmentExpression(node: Node) -> bool;

defLiveAtBBExit 

/**
* Gets the LValue nodes live at the exit of BB.
*/

pub fn defLiveAtBBExit(bb: BasicBlock) -> LValue;

isIndexSignature 

/**
* Determines whether a node is an index signature.
*/
  • Parameter node: Node
  • Return bool
pub fn isIndexSignature(node: Node) -> bool;

isShiftOperator 

/**
* Determines whether a node is a shift operator `<<`, `>>` or `>>>`.
*/
  • Parameter node: Node
  • Return bool
pub fn isShiftOperator(node: Node) -> bool;

isEmptyStatement 

/**
* Determines whether a node is an empty statement.
*/
  • Parameter node: Node
  • Return bool
pub fn isEmptyStatement(node: Node) -> bool;

isAccessor 

/**
* Determines whether a node is an Accessor
*/
  • Parameter node: Node
  • Return bool
pub fn isAccessor(node: Node) -> bool;

isContinueStatement 

/**
* Determines whether a node is a `continue` statement
*/
  • Parameter node: Node
  • Return bool
pub fn isContinueStatement(node: Node) -> bool;

isPropertySignature 

/**
* Determines whether a node is a property signature.
*/
  • Parameter node: Node
  • Return bool
pub fn isPropertySignature(node: Node) -> bool;

isTemplateLiteralTypeSpan 

/**
* Determines whether a node is a template literal type span.
*/
  • Parameter node: Node
  • Return bool
pub fn isTemplateLiteralTypeSpan(node: Node) -> bool;

isUnknown 

/**
* Determines whether a node is an unknown token.
*/
  • Parameter node: Node
  • Return bool
pub fn isUnknown(node: Node) -> bool;

isTupleType 

/**
* Determines whether a node is a tuple type.
*/
  • Parameter node: Node
  • Return bool
pub fn isTupleType(node: Node) -> bool;

isExclamationEqualsEqualsToken 

/**
* Determines whether a node is a `!==` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isExclamationEqualsEqualsToken(node: Node) -> bool;

isRelationalExpression 

/**
* Determines whether a node is a relational expression using `<`, `<=`, `>`, `>=`, `instanceof` or `in`.
*/
  • Parameter node: Node
  • Return bool
pub fn isRelationalExpression(node: Node) -> bool;

flowTo

  • Parameter source: Node
  • Parameter sink: Node
  • Return bool
pub fn flowTo(source: Node, sink: Node) -> bool;

isTypeAssertionExpression 

/**
* Determines whether a node is a type assertion expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isTypeAssertionExpression(node: Node) -> bool;

isTryStatement 

/**
* Determines whether a node is a `try` statement
*/
  • Parameter node: Node
  • Return bool
pub fn isTryStatement(node: Node) -> bool;

isForInStatement 

/**
* Determines whether a node is a `for`-`in` statement
*/
  • Parameter node: Node
  • Return bool
pub fn isForInStatement(node: Node) -> bool;

isCompoundAssignmentOperator 

/**
* Determines whether a node is a compound assignment operator
* `+=`, `-=`, `**=`, `*=`, `/=`, `%=`, `&=`, `|=`, `^=`, `<<=`, `>>=`, `>>>=`,
* `&&=`, `||=` or `??=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isCompoundAssignmentOperator(node: Node) -> bool;

entryBBReachableBB 

/**
* Hold the entry BB and it's all reachable BBs.
*/

pub fn entryBBReachableBB(entryBB: BasicBlock, reachableBB: BasicBlock) -> bool;

isInequalityExpression 

/**
* Determines whether a node is an inequality expression using `!=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isInequalityExpression(node: Node) -> bool;

isStatementButNotDeclaration 

/**
* Determines whether a node is a statement, but not a declaration
*/
  • Parameter node: Node
  • Return bool
pub fn isStatementButNotDeclaration(node: Node) -> bool;

isMinusToken 

/**
* Determines whether a node is a `-` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isMinusToken(node: Node) -> bool;

isMemberExpression 

/**
* Determines whether a node is a member expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isMemberExpression(node: Node) -> bool;

isRegularExpressionLiteral 

/**
* Determines whether a node is a regular expression literal.
*/
  • Parameter node: Node
  • Return bool
pub fn isRegularExpressionLiteral(node: Node) -> bool;

isIterationStatementKind 

/**
* Determines whether a node kind is an iteration statement kind,
* including `while`, `do`-`while`, `for` and enhanced `for` (`for`-`in`, `for`-`of`) statements.
*/
  • Parameter kind: int
  • Return bool
pub fn isIterationStatementKind(kind: int) -> bool;

isPlusEqualsToken 

/**
* Determines whether a node is a `+=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isPlusEqualsToken(node: Node) -> bool;

isNotEmittedStatement 

/**
* Determines whether a node is a not-emmitted statement.
*/
  • Parameter node: Node
  • Return bool
pub fn isNotEmittedStatement(node: Node) -> bool;

isMultiplicativeExpression 

/**
* Determines whether a node is a multiplicative expression using `*`, `/` or `%`.
*/
  • Parameter node: Node
  • Return bool
pub fn isMultiplicativeExpression(node: Node) -> bool;

isSyntheticReferenceExpression 

/**
* Determines whether a node is a synthetic reference expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isSyntheticReferenceExpression(node: Node) -> bool;

isTypeReference 

/**
* Determines whether a node is a type reference.
*/
  • Parameter node: Node
  • Return bool
pub fn isTypeReference(node: Node) -> bool;

isEnhancedForStatement 

/**
* Determines whether a node is a `for`-`in` or `for`-`of` statement
*/
  • Parameter node: Node
  • Return bool
pub fn isEnhancedForStatement(node: Node) -> bool;

bbDominates 

/**
* Hold if domBB dominates bb.
*/

pub fn bbDominates(domBB: BasicBlock, bb: BasicBlock) -> bool;

isLessThanEqualsExpression 

/**
* Determines whether a node is a less-than-or-equal expression using `<=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isLessThanEqualsExpression(node: Node) -> bool;

isGreaterThanEqualsExpression 

/**
* Determines whether a node is a greater-than-or-equal expression using `>=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isGreaterThanEqualsExpression(node: Node) -> bool;

isImportEqualsDeclaration 

/**
* Determines whether a node is an import-equals declaration.
*/
  • Parameter node: Node
  • Return bool
pub fn isImportEqualsDeclaration(node: Node) -> bool;

isNonNullExpression 

/**
* Determines whether a node is a non-null expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isNonNullExpression(node: Node) -> bool;

isTypeParameter 

/**
* Determines whether a node is a type parameter.
*/
  • Parameter node: Node
  • Return bool
pub fn isTypeParameter(node: Node) -> bool;

isQualifiedName 

/**
* Determines whether a node is a qualified name.
*/
  • Parameter node: Node
  • Return bool
pub fn isQualifiedName(node: Node) -> bool;

isModuleDeclaration 

/**
* Determines whether a node is a module declaration.
*/
  • Parameter node: Node
  • Return bool
pub fn isModuleDeclaration(node: Node) -> bool;

isBindingName 

/**
* Determines whether a node is a binding name.
*/
  • Parameter node: Node
  • Return bool
pub fn isBindingName(node: Node) -> bool;

isCallSignature 

/**
* Determines whether a node is a call signature.
*/
  • Parameter node: Node
  • Return bool
pub fn isCallSignature(node: Node) -> bool;

isCaseClause 

/**
* Determines whether a node is an `case` clause
*/
  • Parameter node: Node
  • Return bool
pub fn isCaseClause(node: Node) -> bool;

isDefaultClause 

/**
* Determines whether a node is an `default` clause
*/
  • Parameter node: Node
  • Return bool
pub fn isDefaultClause(node: Node) -> bool;

isClassDeclaration 

/**
* Determines whether a node is a class declaration.
*/
  • Parameter node: Node
  • Return bool
pub fn isClassDeclaration(node: Node) -> bool;

isCaseBlock 

/**
* Determines whether a node is a `switch`-`case` block.
*/
  • Parameter node: Node
  • Return bool
pub fn isCaseBlock(node: Node) -> bool;

isMergeDeclarationMarker 

/**
* Determines whether a node is a merge-declaration marker.
*/
  • Parameter node: Node
  • Return bool
pub fn isMergeDeclarationMarker(node: Node) -> bool;

isVoidExpression 

/**
* Determines whether a node is a `void` expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isVoidExpression(node: Node) -> bool;

isPercentToken 

/**
* Determines whether a node is a `%` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isPercentToken(node: Node) -> bool;

isSwitchStatement 

/**
* Determines whether a node is an `switch` statement
*/
  • Parameter node: Node
  • Return bool
pub fn isSwitchStatement(node: Node) -> bool;

isTypeLiteral 

/**
* Determines whether a node is a type literal.
*/
  • Parameter node: Node
  • Return bool
pub fn isTypeLiteral(node: Node) -> bool;

isFunctionDeclaration 

/**
* Determines whether a node is a function declaration.
*/
  • Parameter node: Node
  • Return bool
pub fn isFunctionDeclaration(node: Node) -> bool;

isShorthandPropertyAssignment 

/**
* Determines whether a node is a shorthand property assignment.
*/
  • Parameter node: Node
  • Return bool
pub fn isShorthandPropertyAssignment(node: Node) -> bool;

isSameRefExpr 

/**
* Determine whether 2 RefExpr with same "symbol".
* Actually we want to determine 2 written locations have alias.
* Current we depend on symbol information calculated by tsc, should
* improve this predicated if needed.
*/

pub fn isSameRefExpr(refExpr1: RefExpr, refExpr2: RefExpr) -> bool;

isJsxClosingElement 

/**
* Determines whether a node is a JSX closing element.
*/
  • Parameter node: Node
  • Return bool
pub fn isJsxClosingElement(node: Node) -> bool;

isMultiplicationExpression 

/**
* Determines whether a node is a multiplication expression using `*`.
*/
  • Parameter node: Node
  • Return bool
pub fn isMultiplicationExpression(node: Node) -> bool;

last 

/**
* Get the node that should be visited last,
* selected from the node and it's descendants.
* Every control flow node must have at least 1 last node.
*/

pub fn last(n: ControlFlowNode, ln: ControlFlowNode, c: Completion) -> bool;

isEndOfDeclarationMarker 

/**
* Determines whether a node is an end-of-declaration marker.
*/
  • Parameter node: Node
  • Return bool
pub fn isEndOfDeclarationMarker(node: Node) -> bool;

isSyntheticExpression 

/**
* Determines whether a node is a synthetic expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isSyntheticExpression(node: Node) -> bool;

isMethodSignature 

/**
* Determines whether a node is a method signature.
*/
  • Parameter node: Node
  • Return bool
pub fn isMethodSignature(node: Node) -> bool;

isDeclarationStatementKind 

/**
* Determines whether a node kind is a declaration statement kind
*/
  • Parameter kind: int
  • Return bool
pub fn isDeclarationStatementKind(kind: int) -> bool;

isJsxExpression 

/**
* Determines whether a node is a JSX closing fragment.
*/
  • Parameter node: Node
  • Return bool
pub fn isJsxExpression(node: Node) -> bool;

isTypeQuery 

/**
* Determines whether a node is a type query.
*/
  • Parameter node: Node
  • Return bool
pub fn isTypeQuery(node: Node) -> bool;

isLessThanEqualsToken 

/**
* Determines whether a node is a `<=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isLessThanEqualsToken(node: Node) -> bool;

isBinaryExpression 

/**
* Determines whether a node is a binary expression
*/
  • Parameter node: Node
  • Return bool
pub fn isBinaryExpression(node: Node) -> bool;

isNamedTupleMember 

/**
* Determines whether a node is a named tuple member.
*/
  • Parameter node: Node
  • Return bool
pub fn isNamedTupleMember(node: Node) -> bool;

isPropertyName 

/**
* Determines whether a node is a property name.
*/
  • Parameter node: Node
  • Return bool
pub fn isPropertyName(node: Node) -> bool;

isBinaryLogicalOperatorOrHigher 

/**
* Determines whether a node is a logical operator or higher.
*/
  • Parameter node: Node
  • Return bool
pub fn isBinaryLogicalOperatorOrHigher(node: Node) -> bool;

isNullKeyword 

/**
* Determines whether a node is a `null` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isNullKeyword(node: Node) -> bool;

isPostfixDecrementExpression 

/**
* Determines whether a node is a postfix decrement expression using `--`.
*/
  • Parameter node: Node
  • Return bool
pub fn isPostfixDecrementExpression(node: Node) -> bool;

isPrefixUnaryOperator 

/**
* Determines whether a node is a prefix unary operator.
*/
  • Parameter node: Node
  • Return bool
pub fn isPrefixUnaryOperator(node: Node) -> bool;

isYieldExpression 

/**
* Determines whether a node is a yield expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isYieldExpression(node: Node) -> bool;

isTemplateSpan 

/**
* Determines whether a node is a template span.
*/
  • Parameter node: Node
  • Return bool
pub fn isTemplateSpan(node: Node) -> bool;

isAdditionAssignmentExpression 

/**
* Determines whether a node is an addition assignment expression using `+=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isAdditionAssignmentExpression(node: Node) -> bool;

isTypeOfExpression 

/**
* Determines whether a node is a `typeof` expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isTypeOfExpression(node: Node) -> bool;

isLogicalAndAssignmentExpression 

/**
* Determines whether a node is a logical AND assignment expression using `&&=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isLogicalAndAssignmentExpression(node: Node) -> bool;

isCaretToken 

/**
* Determines whether a node is a `^` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isCaretToken(node: Node) -> bool;

isMissingDeclaration 

/**
* Determines whether a node is a missing declaration.
*/
  • Parameter node: Node
  • Return bool
pub fn isMissingDeclaration(node: Node) -> bool;

isConditionalType 

/**
* Determines whether a node is a conditional type.
*/
  • Parameter node: Node
  • Return bool
pub fn isConditionalType(node: Node) -> bool;

isIndexedAccessType 

/**
* Determines whether a node is an indexed access type.
*/
  • Parameter node: Node
  • Return bool
pub fn isIndexedAccessType(node: Node) -> bool;

isIfStatement 

/**
* Determines whether a node is an `if` statement
*/
  • Parameter node: Node
  • Return bool
pub fn isIfStatement(node: Node) -> bool;

isConditionalExpression 

/**
* Determines whether a node is a conditional expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isConditionalExpression(node: Node) -> bool;

isAsteriskAsteriskToken 

/**
* Determines whether a node is a `**` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isAsteriskAsteriskToken(node: Node) -> bool;

isPostfixUnaryOperator 

/**
* Determines whether a node is a postfix unary operator.
*/
  • Parameter node: Node
  • Return bool
pub fn isPostfixUnaryOperator(node: Node) -> bool;

isFunctionType 

/**
* Determines whether a node is a function type.
*/
  • Parameter node: Node
  • Return bool
pub fn isFunctionType(node: Node) -> bool;

isPlusPlusToken 

/**
* Determines whether a node is a `++` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isPlusPlusToken(node: Node) -> bool;

nodeInSameCFG 

/**
* Hold if two control flow nodes are in same CFG.
*/

pub fn nodeInSameCFG(cfn1: ControlFlowNode, cfn2: ControlFlowNode) -> bool;

isUnaryExpression 

/**
* Determines whether a node is an unary expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isUnaryExpression(node: Node) -> bool;

isVariableDeclarationKind 

/**
* Determines whether a node kind is a variable declaration kind
*/
  • Parameter kind: int
  • Return bool
pub fn isVariableDeclarationKind(kind: int) -> bool;

isSimpleAssignmentExpression 

/**
* Determines whether a node is a simple assignment expression using `=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isSimpleAssignmentExpression(node: Node) -> bool;

isInterfaceDeclaration 

/**
* Determines whether a node is an interface declaration.
*/
  • Parameter node: Node
  • Return bool
pub fn isInterfaceDeclaration(node: Node) -> bool;

isGetAccessor 

/**
* Determines whether a node is a `get` accessor
*/
  • Parameter node: Node
  • Return bool
pub fn isGetAccessor(node: Node) -> bool;

isKeywordTypeNode 

/**
* Determines whether a node is a keyword type node.
*/
  • Parameter node: Node
  • Return bool
pub fn isKeywordTypeNode(node: Node) -> bool;

isOptionalType 

/**
* Determines whether a node is an optional type.
*/
  • Parameter node: Node
  • Return bool
pub fn isOptionalType(node: Node) -> bool;

isInferType 

/**
* Determines whether a node is an infer type.
*/
  • Parameter node: Node
  • Return bool
pub fn isInferType(node: Node) -> bool;

isExpressionWithTypeArguments 

/**
* Determines whether a node is an expression with type arguments.
*/
  • Parameter node: Node
  • Return bool
pub fn isExpressionWithTypeArguments(node: Node) -> bool;

isConstructor 

/**
* Determines whether a node is a Constructor
*/
  • Parameter node: Node
  • Return bool
pub fn isConstructor(node: Node) -> bool;

isMappedType 

/**
* Determines whether a node is a mapped type.
*/
  • Parameter node: Node
  • Return bool
pub fn isMappedType(node: Node) -> bool;

isTemplateLiteralType 

/**
* Determines whether a node is a template literal type.
*/
  • Parameter node: Node
  • Return bool
pub fn isTemplateLiteralType(node: Node) -> bool;

isLeftHandSideExpression 

/**
* Determines whether a node is a left-hand-side expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isLeftHandSideExpression(node: Node) -> bool;

isBigIntLiteral 

/**
* Determines whether a node is a big-int literal.
*/
  • Parameter node: Node
  • Return bool
pub fn isBigIntLiteral(node: Node) -> bool;

isImportType 

/**
* Determines whether a node is an import type.
*/
  • Parameter node: Node
  • Return bool
pub fn isImportType(node: Node) -> bool;

isTypeNode 

/**
* Determines whether a node is a type node.
*/
  • Parameter node: Node
  • Return bool
pub fn isTypeNode(node: Node) -> bool;

isClassElement 

/**
* Determines whether a node is a ClassElement
*/
  • Parameter node: Node
  • Return bool
pub fn isClassElement(node: Node) -> bool;

isNonStrictEqualityTestExpression 

/**
* Determines whether a node is a non-strict equality test expression using
* `==` or `!=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isNonStrictEqualityTestExpression(node: Node) -> bool;

isJsxSpreadAttribute 

/**
* Determines whether a node is a JSX spread attribute.
*/
  • Parameter node: Node
  • Return bool
pub fn isJsxSpreadAttribute(node: Node) -> bool;

isLiteralExpression 

/**
* Determines whether a node is a literal expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isLiteralExpression(node: Node) -> bool;

isBinaryBitwiseExpression 

/**
* Determines whether a node is a binary bitwise expression using
* `&`, `|` or `^`.
*/
  • Parameter node: Node
  • Return bool
pub fn isBinaryBitwiseExpression(node: Node) -> bool;

isBitwiseOrExpression 

/**
* Determines whether a node is a bitwise OR expression using `|`.
*/
  • Parameter node: Node
  • Return bool
pub fn isBitwiseOrExpression(node: Node) -> bool;

isBitwiseXorExpression 

/**
* Determines whether a node is a bitwise XOR expression using `^`.
*/
  • Parameter node: Node
  • Return bool
pub fn isBitwiseXorExpression(node: Node) -> bool;

isBinaryLogicalExpression 

/**
* Determines whether a node is a binary logical expression using
* `&&`, `||` or `??`.
*/
  • Parameter node: Node
  • Return bool
pub fn isBinaryLogicalExpression(node: Node) -> bool;

isLogicalAndExpression 

/**
* Determines whether a node is a logical AND expression using `&&`.
*/
  • Parameter node: Node
  • Return bool
pub fn isLogicalAndExpression(node: Node) -> bool;

isAssignmentExpression 

/**
* Determines whether a node is an assignment expression, either compound or simple.
*/
  • Parameter node: Node
  • Return bool
pub fn isAssignmentExpression(node: Node) -> bool;

isCompoundAssignmentExpression 

/**
* Determines whether a node is a compound assignment expression using
* `+=`, `-=`, `**=`, `*=`, `/=`, `%=`, `&=`, `|=`, `^=`, `<<=`, `>>=`, `>>>=`,
* `&&=`, `||=` or `??=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isCompoundAssignmentExpression(node: Node) -> bool;

isSubtractionAssignmentExpression 

/**
* Determines whether a node is a subtraction assignment expression using `-=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isSubtractionAssignmentExpression(node: Node) -> bool;

isExponentiationAssignmentExpression 

/**
* Determines whether a node is an exponentiation assignment expression using `**=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isExponentiationAssignmentExpression(node: Node) -> bool;

isModifierKind 

/**
* Determines whether a node kind is a modifier kind.
*/
  • Parameter kind: int
  • Return bool
pub fn isModifierKind(kind: int) -> bool;

isMultiplicationAssignmentExpression 

/**
* Determines whether a node is a multiplication assignment expression using `*=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isMultiplicationAssignmentExpression(node: Node) -> bool;

isBitwiseOrAssignmentExpression 

/**
* Determines whether a node is a bitwise OR assignment expression using `|=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isBitwiseOrAssignmentExpression(node: Node) -> bool;

isUnsignedRightShiftAssignmentExpression 

/**
* Determines whether a node is an unsigned right shift assignment expression using `>>>=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isUnsignedRightShiftAssignmentExpression(node: Node) -> bool;

routerKindInit

  • Parameter id: int
  • Parameter name: string
  • Return bool
pub fn routerKindInit(id: int, name: string) -> bool;

isNullishAssignmentExpression 

/**
* Determines whether a node is a nullish assignment expression using `??=`.
*/
  • Parameter node: Node
  • Return bool
pub fn isNullishAssignmentExpression(node: Node) -> bool;

isIntrinsicKeyword 

/**
* Determines whether a node is an `intrinsic` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isIntrinsicKeyword(node: Node) -> bool;

isCommaExpression 

/**
* Determines whether a node is a comma expression using `,`.
*/
  • Parameter node: Node
  • Return bool
pub fn isCommaExpression(node: Node) -> bool;

isPrefixDecrementExpression 

/**
* Determines whether a node is a prefix decrement expression using `--`.
*/
  • Parameter node: Node
  • Return bool
pub fn isPrefixDecrementExpression(node: Node) -> bool;

isUnknownKeyword 

/**
* Determines whether a node is an `unknown` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isUnknownKeyword(node: Node) -> bool;

isUnaryPlusExpression 

/**
* Determines whether a node is an unary plus expression using `+`.
*/
  • Parameter node: Node
  • Return bool
pub fn isUnaryPlusExpression(node: Node) -> bool;

isUnaryMinusExpression 

/**
* Determines whether a node is an unary minus (also known as negation) expression using `-`.
*/
  • Parameter node: Node
  • Return bool
pub fn isUnaryMinusExpression(node: Node) -> bool;

isBitwiseNotExpression 

/**
* Determines whether a node is a bitwise NOT expression using `~`.
*/
  • Parameter node: Node
  • Return bool
pub fn isBitwiseNotExpression(node: Node) -> bool;

isLogicalNotExpression 

/**
* Determines whether a node is a logical NOT expression using `!`.
*/
  • Parameter node: Node
  • Return bool
pub fn isLogicalNotExpression(node: Node) -> bool;

bbNotDominates 

/**
* Hold if ndomBB don't dominates bb.
*/

pub fn bbNotDominates(ndomBB: BasicBlock, bb: BasicBlock) -> bool;

isContinueCompletion 

pub fn isContinueCompletion(c: Completion) -> bool;

isIncrementExpression 

/**
* Determines whether a node is an increment expression using `++`.
*/
  • Parameter node: Node
  • Return bool
pub fn isIncrementExpression(node: Node) -> bool;

isMemberName 

/**
* Determines whether a node is a member name.
*/
  • Parameter node: Node
  • Return bool
pub fn isMemberName(node: Node) -> bool;

isPropertyAssignment 

/**
* Determines whether a node is a property assignment.
*/
  • Parameter node: Node
  • Return bool
pub fn isPropertyAssignment(node: Node) -> bool;

isObjectBindingPattern 

/**
* Determines whether a node is an object binding pattern.
*/
  • Parameter node: Node
  • Return bool
pub fn isObjectBindingPattern(node: Node) -> bool;

isExpressionStatement 

/**
* Determines whether a node is an expression statement
*/
  • Parameter node: Node
  • Return bool
pub fn isExpressionStatement(node: Node) -> bool;

isAccessExpression 

/**
* Determines whether a node is an access expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isAccessExpression(node: Node) -> bool;

isDecorator 

/**
* Determines whether a node is a decorator.
*/
  • Parameter node: Node
  • Return bool
pub fn isDecorator(node: Node) -> bool;

isCallLikeExpression 

/**
* Determines whether a node is a call-like expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isCallLikeExpression(node: Node) -> bool;

isMayInvokeExpression 

/**
* Determines whether a node is a CallLikeExpression or AccessExpression that may invoke a FunctionLikeDeclaration.
*/
  • Parameter node: Node
  • Return bool
pub fn isMayInvokeExpression(node: Node) -> bool;

postDominanceFrontier 

/**
* Hold bb's post dominance frontier.
* bb post dominates at least one of pdf's successor,
* but bb don't strictly post dominates pdf.
*/

pub fn postDominanceFrontier(bb: BasicBlock, pdf: BasicBlock) -> bool;

isDecrementExpression 

/**
* Determines whether a node is a decrement expression using `--`.
*/
  • Parameter node: Node
  • Return bool
pub fn isDecrementExpression(node: Node) -> bool;

isFalseBooleanCompletion 

pub fn isFalseBooleanCompletion(c: Completion) -> bool;

isObjectKeyword 

/**
* Determines whether a node is an `object` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isObjectKeyword(node: Node) -> bool;

isQuestionQuestionEqualsToken 

/**
* Determines whether a node is a `??=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isQuestionQuestionEqualsToken(node: Node) -> bool;

defn 

pub fn defn(def: ControlFlowNode, lhs: Expression) -> bool;

isFirstOfBasicBlock 

/**
* Hold if the node is the first node of a basic block.
*/

pub fn isFirstOfBasicBlock(cfn: ControlFlowNode) -> bool;

isPercentEqualsToken 

/**
* Determines whether a node is a `%=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isPercentEqualsToken(node: Node) -> bool;

isBigIntKeyword 

/**
* Determines whether a node is a `bigint` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isBigIntKeyword(node: Node) -> bool;

pageRouterRule 

pub fn pageRouterRule(fromPage: PageObject, toPage: PageObject, kind: RouterKind) -> bool;

isJsxFragment 

/**
* Determines whether a node is a JSX fragment.
*/
  • Parameter node: Node
  • Return bool
pub fn isJsxFragment(node: Node) -> bool;

isProtectedKeyword 

/**
* Determines whether a node is a `protected` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isProtectedKeyword(node: Node) -> bool;

isStringKeyword 

/**
* Determines whether a node is a `string` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isStringKeyword(node: Node) -> bool;

isNodeWithTypeArguments 

/**
* Determines whether a node is a node with type arguments.
*/
  • Parameter node: Node
  • Return bool
pub fn isNodeWithTypeArguments(node: Node) -> bool;

defnWithRhs 

pub fn defnWithRhs(def: ControlFlowNode, lhs: Expression, rhs: Expression) -> bool;

isLValue

  • Parameter refExpr: RefExpr
  • Return bool
pub fn isLValue(refExpr: RefExpr) -> bool;

isHeritageToken 

/**
* Determines whether a node is a heritage token, that is an `extends` or `implements` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isHeritageToken(node: Node) -> bool;

isPropertyNameInPropertyAssignment 

/**
* Determine a PropertyName expr exists in a PropertyAssignment expr.
*/

pub fn isPropertyNameInPropertyAssignment(propertyName: PropertyName) -> bool;

isConstructSignature 

/**
* Determines whether a node is a construct signature.
*/
  • Parameter node: Node
  • Return bool
pub fn isConstructSignature(node: Node) -> bool;

isRValue

  • Parameter refExpr: RefExpr
  • Return bool
pub fn isRValue(refExpr: RefExpr) -> bool;

defAtBB 

/**
* Gets the lvalue defined in bb, with bb index
*/
  • Parameter bb: BasicBlock
  • Parameter lvalue: LValue
  • Parameter index: int
  • Return bool
pub fn defAtBB(bb: BasicBlock, lvalue: LValue, index: int) -> bool;

useAtBB 

/**
* Gets the VarUse used in bb, with bb index
*/
  • Parameter bb: BasicBlock
  • Parameter varUse: VarUse
  • Parameter index: int
  • Return bool
pub fn useAtBB(bb: BasicBlock, varUse: VarUse, index: int) -> bool;

getSymbol 

/**
* Get the corresponding symbol of a RefExpr.
* It also gets the value symbol of a ShorthandPropertyAssignment or the name node (Identifier) of it.
*/

pub fn getSymbol(refExpr: RefExpr) -> Symbol;

killedByBB 

/**
* Determine whether the lvalue is killed by bb.
*/

pub fn killedByBB(bb: BasicBlock, lvalue: LValue) -> bool;

indirectFlowEdge 

pub fn indirectFlowEdge(predecessor: DataFlowNode, successor: DataFlowNode) -> bool;

dominanceFrontier 

/**
* Hold bb's dominance frontier.
* bb dominates at least one of df's predecessor,
* but bb don't strictly dominates df.
*/

pub fn dominanceFrontier(bb: BasicBlock, df: BasicBlock) -> bool;

defLiveAtBBEntry 

/**
* Gets the LValue nodes live at the entry of BB.
*/

pub fn defLiveAtBBEntry(bb: BasicBlock) -> LValue;

isUpdateExpression 

/**
* Determines whether a node is an update expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isUpdateExpression(node: Node) -> bool;

bbInSameCFG 

/**
* Hold if two bb are in same CFG.
*/

pub fn bbInSameCFG(bb1: BasicBlock, bb2: BasicBlock) -> bool;

dominates 

/**
* Hold if dom dominates cfn.
*/

pub fn dominates(dom: ControlFlowNode, cfn: ControlFlowNode) -> bool;

bbPostDominates 

/**
* Hold if pdomBB post dominates bb.
*/

pub fn bbPostDominates(pdomBB: BasicBlock, bb: BasicBlock) -> bool;

bbStrictPostDominates 

/**
* Hold if spdom strictly post dominates bb.
*/

pub fn bbStrictPostDominates(spdomBB: BasicBlock, bb: BasicBlock) -> bool;

controlDependencies 

/**
* Hold bb's control dependencies.
* same with postDominanceFrontier+.
*/

pub fn controlDependencies(bb: BasicBlock, controlDependencyBB: BasicBlock) -> bool;

isDataFlowNode

  • Parameter node: Node
  • Return bool
pub fn isDataFlowNode(node: Node) -> bool;

lvalueFlowEdge 

pub fn lvalueFlowEdge(predecessor: DataFlowNode, successor: DataFlowNode) -> bool;

isNormalCompletion 

pub fn isNormalCompletion(c: Completion) -> bool;

isReturnCompletion 

pub fn isReturnCompletion(c: Completion) -> bool;

isAccessorKind 

/**
* Determines whether a node kind is an Accessor kind
*/
  • Parameter kind: int
  • Return bool
pub fn isAccessorKind(kind: int) -> bool;

isBooleanCompletion 

pub fn isBooleanCompletion(c: Completion) -> bool;

isThisType 

/**
* Determines whether a node is a this type.
*/
  • Parameter node: Node
  • Return bool
pub fn isThisType(node: Node) -> bool;

isTrueBooleanCompletion 

pub fn isTrueBooleanCompletion(c: Completion) -> bool;

isNullLiteral 

/**
* Determines whether a node is a null literal.
*/
  • Parameter node: Node
  • Return bool
pub fn isNullLiteral(node: Node) -> bool;

isBreakCompletion 

pub fn isBreakCompletion(c: Completion) -> bool;

isYieldCompletion 

pub fn isYieldCompletion(c: Completion) -> bool;

completion

  • Parameter id: int
  • Parameter name: string
  • Return bool
pub fn completion(id: int, name: string) -> bool;

isInKeyword 

/**
* Determines whether a node is an `in` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isInKeyword(node: Node) -> bool;

isGreaterThanGreaterThanEqualsToken 

/**
* Determines whether a node is a `>>=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isGreaterThanGreaterThanEqualsToken(node: Node) -> bool;

isNamespaceExportDeclaration 

/**
* Determines whether a node is a namespace export declaration.
*/
  • Parameter node: Node
  • Return bool
pub fn isNamespaceExportDeclaration(node: Node) -> bool;

isClassLikeDeclaration 

/**
* Determines whether a node is a ClassLikeDeclaration
*/
  • Parameter node: Node
  • Return bool
pub fn isClassLikeDeclaration(node: Node) -> bool;

isClassLikeDeclarationKind 

/**
* Determines whether a node kind is a ClassLikeDeclaration kind
*/
  • Parameter kind: int
  • Return bool
pub fn isClassLikeDeclarationKind(kind: int) -> bool;

isClassElementKind 

/**
* Determines whether a node kind is a ClassElement kind
*/
  • Parameter kind: int
  • Return bool
pub fn isClassElementKind(kind: int) -> bool;

isPlusToken 

/**
* Determines whether a node is a `+` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isPlusToken(node: Node) -> bool;

isBooleanLiteral 

/**
* Determines whether a node is a boolean literal.
*/
  • Parameter node: Node
  • Return bool
pub fn isBooleanLiteral(node: Node) -> bool;

isCaretEqualsToken 

/**
* Determines whether a node is a `^=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isCaretEqualsToken(node: Node) -> bool;

bbStrictDominates 

/**
* Hold if sdomBB strictly dominates bb.
*/

pub fn bbStrictDominates(sdomBB: BasicBlock, bb: BasicBlock) -> bool;

isVariableDeclaration 

/**
* Determines whether a node is a variable declaration
*/
  • Parameter node: Node
  • Return bool
pub fn isVariableDeclaration(node: Node) -> bool;

isArrayBindingPattern 

/**
* Determines whether a node is an array binding pattern.
*/
  • Parameter node: Node
  • Return bool
pub fn isArrayBindingPattern(node: Node) -> bool;

isNumberKeyword 

/**
* Determines whether a node is a `number` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isNumberKeyword(node: Node) -> bool;

isBindingElement 

/**
* Determines whether a node is a binding element.
*/
  • Parameter node: Node
  • Return bool
pub fn isBindingElement(node: Node) -> bool;

isEnumDeclaration 

/**
* Determines whether a node is an enum declaration.
*/
  • Parameter node: Node
  • Return bool
pub fn isEnumDeclaration(node: Node) -> bool;

isLiteralType 

/**
* Determines whether a node is a literal type.
*/
  • Parameter node: Node
  • Return bool
pub fn isLiteralType(node: Node) -> bool;

isBindingPattern 

/**
* Determines whether a node is a binding pattern.
*/
  • Parameter node: Node
  • Return bool
pub fn isBindingPattern(node: Node) -> bool;

isEnumMember 

/**
* Determines whether a node is an enum member.
*/
  • Parameter node: Node
  • Return bool
pub fn isEnumMember(node: Node) -> bool;

inBooleanContext 

/**
* a node that occur in a context in which their value affect control flow.
*/

pub fn inBooleanContext(n: ControlFlowNode) -> bool;

isExportDeclaration 

/**
* Determines whether a node is an export declaration.
*/
  • Parameter node: Node
  • Return bool
pub fn isExportDeclaration(node: Node) -> bool;

isImportDeclaration 

/**
* Determines whether a node is an import declaration.
*/
  • Parameter node: Node
  • Return bool
pub fn isImportDeclaration(node: Node) -> bool;

immediateFlowEdge 

pub fn immediateFlowEdge(predecessor: DataFlowNode, successor: DataFlowNode) -> bool;

isJsxElement 

/**
* Determines whether a node is a JSX element.
*/
  • Parameter node: Node
  • Return bool
pub fn isJsxElement(node: Node) -> bool;

isJsxOpeningElement 

/**
* Determines whether a node is a JSX opening element.
*/
  • Parameter node: Node
  • Return bool
pub fn isJsxOpeningElement(node: Node) -> bool;

isJsxClosingFragment 

/**
* Determines whether a node is a JSX closing fragment.
*/
  • Parameter node: Node
  • Return bool
pub fn isJsxClosingFragment(node: Node) -> bool;

isJsxAttribute 

/**
* Determines whether a node is a JSX attribute.
*/
  • Parameter node: Node
  • Return bool
pub fn isJsxAttribute(node: Node) -> bool;

isJsxAttributes 

/**
* Determines whether a node is a JSX attributes.
*/
  • Parameter node: Node
  • Return bool
pub fn isJsxAttributes(node: Node) -> bool;

isParameter 

/**
* Determines whether a node kind is a parameter.
*/
  • Parameter node: Node
  • Return bool
pub fn isParameter(node: Node) -> bool;

isHeritageClause 

/**
* Determines whether a node is a heritage clause.
*/
  • Parameter node: Node
  • Return bool
pub fn isHeritageClause(node: Node) -> bool;

isNumericLiteral 

/**
* Determines whether a node is a numeric literal.
*/
  • Parameter node: Node
  • Return bool
pub fn isNumericLiteral(node: Node) -> bool;

isGreaterThanGreaterThanGreaterThanToken 

/**
* Determines whether a node is a `>>>` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isGreaterThanGreaterThanGreaterThanToken(node: Node) -> bool;

isBlockStatement 

/**
* Determines whether a node is a block statement
*/
  • Parameter node: Node
  • Return bool
pub fn isBlockStatement(node: Node) -> bool;

isVariableDeclarationList 

/**
* Determines whether a node is a variable declaration list
*/
  • Parameter node: Node
  • Return bool
pub fn isVariableDeclarationList(node: Node) -> bool;

isQuestionToken 

/**
* Determines whether a node is a `?` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isQuestionToken(node: Node) -> bool;

isPartiallyEmittedExpression 

/**
* Determines whether a node is a partially emitted expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isPartiallyEmittedExpression(node: Node) -> bool;

isTrueKeyword 

/**
* Determines whether a node is a `true` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isTrueKeyword(node: Node) -> bool;

isVariableDeclarationListKind 

/**
* Determines whether a node kind is a variable declaration list kind
*/
  • Parameter kind: int
  • Return bool
pub fn isVariableDeclarationListKind(kind: int) -> bool;

isPrivateKeyword 

/**
* Determines whether a node is a `private` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isPrivateKeyword(node: Node) -> bool;

isConstructorType 

/**
* Determines whether a node is a constructor type.
*/
  • Parameter node: Node
  • Return bool
pub fn isConstructorType(node: Node) -> bool;

isWhileStatement 

/**
* Determines whether a node is a `while` statement
*/
  • Parameter node: Node
  • Return bool
pub fn isWhileStatement(node: Node) -> bool;

isParenthesizedType 

/**
* Determines whether a node is a parenthesized type.
*/
  • Parameter node: Node
  • Return bool
pub fn isParenthesizedType(node: Node) -> bool;

isPrivateIdentifier 

/**
* Determines whether a node is a private identifier.
*/
  • Parameter node: Node
  • Return bool
pub fn isPrivateIdentifier(node: Node) -> bool;

isGreaterThanEqualsToken 

/**
* Determines whether a node is a `>=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isGreaterThanEqualsToken(node: Node) -> bool;

isGreaterThanGreaterThanToken 

/**
* Determines whether a node is a `>>` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isGreaterThanGreaterThanToken(node: Node) -> bool;

isFunctionTypeOrSignatureKind 

/**
* Determines whether a node kind is a FunctionTypeOrSignature kind
*/
  • Parameter kind: int
  • Return bool
pub fn isFunctionTypeOrSignatureKind(kind: int) -> bool;

isArrayBindingElement 

/**
* Determines whether a node is an array binding element.
*/
  • Parameter node: Node
  • Return bool
pub fn isArrayBindingElement(node: Node) -> bool;

isSuperKeyword 

/**
* Determines whether a node is a `super` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isSuperKeyword(node: Node) -> bool;

postDominates 

/**
* Hold if pdom post dominates cfn.
*/

pub fn postDominates(pdom: ControlFlowNode, cfn: ControlFlowNode) -> bool;

isArrowFunction 

/**
* Determines whether a node is an arrow function
*/
  • Parameter node: Node
  • Return bool
pub fn isArrowFunction(node: Node) -> bool;

isVoidKeyword 

/**
* Determines whether a node is a `void` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isVoidKeyword(node: Node) -> bool;

isNewExpression 

/**
* Determines whether a node is a new expression.
*/
  • Parameter node: Node
  • Return bool
pub fn isNewExpression(node: Node) -> bool;

isAmpersandAmpersandToken 

/**
* Determines whether a node is an `&&` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isAmpersandAmpersandToken(node: Node) -> bool;

isToken 

/**
* Determines whether a node is a token.
*/
  • Parameter node: Node
  • Return bool
pub fn isToken(node: Node) -> bool;

isForOfStatement 

/**
* Determines whether a node is a `for`-`of` statement
*/
  • Parameter node: Node
  • Return bool
pub fn isForOfStatement(node: Node) -> bool;

isEndOfFileToken 

/**
* Determines whether a node is an end-of-file token.
*/
  • Parameter node: Node
  • Return bool
pub fn isEndOfFileToken(node: Node) -> bool;

isStringLiteral 

/**
* Determines whether a node is a string literal.
*/
  • Parameter node: Node
  • Return bool
pub fn isStringLiteral(node: Node) -> bool;

isLessThanLessThanEqualsToken 

/**
* Determines whether a node is a `<<=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isLessThanLessThanEqualsToken(node: Node) -> bool;

isJsxText 

/**
* Determines whether a node is a JSX text.
*/
  • Parameter node: Node
  • Return bool
pub fn isJsxText(node: Node) -> bool;

isNoSubstitutionTemplateLiteral 

/**
* Determines whether a node is a no-substitution template literal.
*/
  • Parameter node: Node
  • Return bool
pub fn isNoSubstitutionTemplateLiteral(node: Node) -> bool;

isTemplateHead 

/**
* Determines whether a node is a template head.
*/
  • Parameter node: Node
  • Return bool
pub fn isTemplateHead(node: Node) -> bool;

isTemplateMiddle 

/**
* Determines whether a node is a template middle.
*/
  • Parameter node: Node
  • Return bool
pub fn isTemplateMiddle(node: Node) -> bool;

isDotDotDotToken 

/**
* Determines whether a node is a `...` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isDotDotDotToken(node: Node) -> bool;

isQuestionDotToken 

/**
* Determines whether a node is a `?.` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isQuestionDotToken(node: Node) -> bool;

isLessThanToken 

/**
* Determines whether a node is a `<` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isLessThanToken(node: Node) -> bool;

isGreaterThanToken 

/**
* Determines whether a node is a `>` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isGreaterThanToken(node: Node) -> bool;

isExclamationEqualsToken 

/**
* Determines whether a node is a `!=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isExclamationEqualsToken(node: Node) -> bool;

isEqualsEqualsEqualsToken 

/**
* Determines whether a node is an `===` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isEqualsEqualsEqualsToken(node: Node) -> bool;

isComputedPropertyName 

/**
* Determines whether a node is a computed property name.
*/
  • Parameter node: Node
  • Return bool
pub fn isComputedPropertyName(node: Node) -> bool;

isSlashToken 

/**
* Determines whether a node is a `/` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isSlashToken(node: Node) -> bool;

isMinusMinusToken 

/**
* Determines whether a node is a `--` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isMinusMinusToken(node: Node) -> bool;

isPropertyExpressionInAccessExpression

  • Parameter propertyExpression: Expression
  • Return bool
pub fn isPropertyExpressionInAccessExpression(propertyExpression: Expression) -> bool;

isEqualsEqualsToken 

/**
* Determines whether a node is an `==` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isEqualsEqualsToken(node: Node) -> bool;

isAmpersandToken 

/**
* Determines whether a node is a `&` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isAmpersandToken(node: Node) -> bool;

isExtendsKeyword 

/**
* Determines whether a node is an `extends` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isExtendsKeyword(node: Node) -> bool;

isBarToken 

/**
* Determines whether a node is a `|` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isBarToken(node: Node) -> bool;

isExclamationToken 

/**
* Determines whether a node is an `!` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isExclamationToken(node: Node) -> bool;

isEqualsToken 

/**
* Determines whether a node is an `=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isEqualsToken(node: Node) -> bool;

isMinusEqualsToken 

/**
* Determines whether a node is a `-=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isMinusEqualsToken(node: Node) -> bool;

isSlashEqualsToken 

/**
* Determines whether a node is a `/=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isSlashEqualsToken(node: Node) -> bool;

isJsxSelfClosingElement 

/**
* Determines whether a node is a JSX self closing element.
*/
  • Parameter node: Node
  • Return bool
pub fn isJsxSelfClosingElement(node: Node) -> bool;

isGreaterThanGreaterThanGreaterThanEqualsToken 

/**
* Determines whether a node is a `>>>=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isGreaterThanGreaterThanGreaterThanEqualsToken(node: Node) -> bool;

isAmpersandEqualsToken 

/**
* Determines whether a node is an `&=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isAmpersandEqualsToken(node: Node) -> bool;

isBarBarEqualsToken 

/**
* Determines whether a node is a `||=` token.
*/
  • Parameter node: Node
  • Return bool
pub fn isBarBarEqualsToken(node: Node) -> bool;

isFalseKeyword 

/**
* Determines whether a node is a `false` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isFalseKeyword(node: Node) -> bool;

isImportKeyword 

/**
* Determines whether a node is an `import` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isImportKeyword(node: Node) -> bool;

isInstanceOfKeyword 

/**
* Determines whether a node is an `instanceof` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isInstanceOfKeyword(node: Node) -> bool;

isThisKeyword 

/**
* Determines whether a node is a `this` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isThisKeyword(node: Node) -> bool;

isImplementsKeyword 

/**
* Determines whether a node is an `implements` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isImplementsKeyword(node: Node) -> bool;

isAnyKeyword 

/**
* Determines whether a node is an `any` keyword.
*/
  • Parameter node: Node
  • Return bool
pub fn isAnyKeyword(node: Node) -> bool;

isExponentiationOperator 

/**
* Determines whether a node is an exponentiation operator `**`.
*/
  • Parameter node: Node
  • Return bool
pub fn isExponentiationOperator(node: Node) -> bool;

isMultiplicativeOperator 

/**
* Determines whether a node is a multiplicative operator `*`, `/` or `%`.
*/
  • Parameter node: Node
  • Return bool
pub fn isMultiplicativeOperator(node: Node) -> bool;