package ast

import (

"fmt"

"slices"

"strings"

"sync"

"sync/atomic"

"github.com/microsoft/TypeScript/tsc/internal/core"

"github.com/microsoft/TypeScript/tsc/internal/debug"

"github.com/microsoft/TypeScript/tsc/internal/tspath"

)

// Atomic ids

var (

nextNodeId atomic.Uint64

nextSymbolId atomic.Uint64

nextNodeBlockId atomic.Uint64

nextSymbolBlockId atomic.Uint64

)

func GetNodeId(node *Node) NodeId {

id := node.id.Load()

if id == 0 {

// Worst case, we burn a few ids if we have to CAS.

id = nextNodeId.Add(1)

if !node.id.CompareAndSwap(0, id) {

id = node.id.Load()

}

}

return NodeId(id)

}

func GetSymbolId(symbol *Symbol) SymbolId {

id := symbol.id.Load()

if id == 0 {

// Worst case, we burn a few ids if we have to CAS.

id = nextSymbolId.Add(1)

if !symbol.id.CompareAndSwap(0, id) {

id = symbol.id.Load()

}

}

return SymbolId(id)

}

const (

BlockIdOffset = 0x1_0000_0000_0000

BlockIdSize = core.LinkPageSize

)

type NodeIdGenerator struct {

nextId uint64

lastId uint64

}

func (a *NodeIdGenerator) GetNodeId(node *Node) NodeId {

id := node.id.Load()

if id == 0 {

if a.nextId == a.lastId {

a.nextId = nextNodeBlockId.Add(BlockIdSize) - BlockIdSize

a.lastId = a.nextId + BlockIdSize

}

id = a.nextId + BlockIdOffset

a.nextId++

if !node.id.CompareAndSwap(0, id) {

id = node.id.Load()

}

}

return NodeId(id)

}

type SymbolIdGenerator struct {

nextId uint64

lastId uint64

}

func (a *SymbolIdGenerator) GetSymbolId(symbol *Symbol) SymbolId {

id := symbol.id.Load()

if id == 0 {

if a.nextId == a.lastId {

a.nextId = nextSymbolBlockId.Add(BlockIdSize) - BlockIdSize

a.lastId = a.nextId + BlockIdSize

}

id = a.nextId + BlockIdOffset

a.nextId++

if !symbol.id.CompareAndSwap(0, id) {

id = symbol.id.Load()

}

}

return SymbolId(id)

}

func GetSymbolTable(data *SymbolTable) SymbolTable {

if *data == nil {

*data = NewSymbolTable()

}

return *data

}

func GetMembers(symbol *Symbol, arena *SymbolExtraArena) SymbolTable {

return GetSymbolTable(&symbol.ensureExtra(arena).members)

}

func GetExports(symbol *Symbol, arena *SymbolExtraArena) SymbolTable {

return GetSymbolTable(&symbol.ensureExtra(arena).exports)

}

func GetLocals(container *Node) SymbolTable {

return GetSymbolTable(&container.LocalsContainerData().Locals)

}

// Determines if a node is missing (either `nil` or empty)

func NodeIsMissing(node *Node) bool {

return node == nil || node.Loc.Pos() == node.Loc.End() && node.Loc.Pos() >= 0 && node.Kind != KindEndOfFile

}

// Determines if a node is present

func NodeIsPresent(node *Node) bool {

return !NodeIsMissing(node)

}

// Determines if a node contains synthetic positions

func NodeIsSynthesized(node *Node) bool {

return PositionIsSynthesized(node.Loc.Pos()) || PositionIsSynthesized(node.Loc.End())

}

func RangeIsSynthesized(loc core.TextRange) bool {

return PositionIsSynthesized(loc.Pos()) || PositionIsSynthesized(loc.End())

}

// Determines whether a position is synthetic

func PositionIsSynthesized(pos int) bool {

return pos < 0

}

func FindLastVisibleNode(nodes []*Node) *Node {

fromEnd := 1

for fromEnd <= len(nodes) && nodes[len(nodes)-fromEnd].Flags&NodeFlagsReparsed != 0 {

fromEnd++

}

if fromEnd <= len(nodes) {

return nodes[len(nodes)-fromEnd]

}

return nil

}

func NodeKindIs(node *Node, kinds ...Kind) bool {

return slices.Contains(kinds, node.Kind)

}

func IsModifier(node *Node) bool {

return IsModifierKind(node.Kind)

}

func IsModifierLike(node *Node) bool {

return IsModifier(node) || IsDecorator(node)

}

func IsCompoundAssignment(token Kind) bool {

return token >= KindFirstCompoundAssignment && token <= KindLastCompoundAssignment

}

func IsAssignmentExpression(node *Node, excludeCompoundAssignment bool) bool {

if node.Kind == KindBinaryExpression {

expr := node.AsBinaryExpression()

return (expr.OperatorToken.Kind == KindEqualsToken || !excludeCompoundAssignment && IsAssignmentOperator(expr.OperatorToken.Kind)) &&

IsLeftHandSideExpression(expr.Left)

}

return false

}

func GetRightMostAssignedExpression(node *Node) *Node {

for IsAssignmentExpression(node, false /*excludeCompoundAssignment*/) {

node = node.AsBinaryExpression().Right

}

return node

}

func IsDestructuringAssignment(node *Node) bool {

if IsAssignmentExpression(node, true /*excludeCompoundAssignment*/) {

kind := node.AsBinaryExpression().Left.Kind

return kind == KindObjectLiteralExpression || kind == KindArrayLiteralExpression

}

return false

}

func IsObjectBindingOrAssignmentElement(node *Node) bool {

switch node.Kind {

case KindBindingElement,

KindPropertyAssignment,

KindShorthandPropertyAssignment,

KindSpreadAssignment:

return true

}

return false

}

func IsArrayBindingOrAssignmentElement(node *Node) bool {

switch node.Kind {

case KindBindingElement,

KindOmittedExpression,

KindSpreadElement,

KindArrayLiteralExpression,

KindObjectLiteralExpression,

KindIdentifier,

KindPropertyAccessExpression,

KindElementAccessExpression:

return true

}

return IsAssignmentExpression(node, true /*excludeCompoundAssignment*/)

}

func IsBindingPattern(node *Node) bool {

return node.Kind == KindObjectBindingPattern || node.Kind == KindArrayBindingPattern

}

func IsForInOrOfStatement(node *Node) bool {

return node != nil && (node.Kind == KindForInStatement || node.Kind == KindForOfStatement)

}

// A node is an assignment target if it is on the left hand side of an '=' token, if it is parented by a property

// assignment in an object literal that is an assignment target, or if it is parented by an array literal that is

// an assignment target. Examples include 'a = xxx', '{ p: a } = xxx', '[{ a }] = xxx'.

// (Note that `p` is not a target in the above examples, only `a`.)

func IsAssignmentTarget(node *Node) bool {

return GetAssignmentTarget(node) != nil

}

// Returns the BinaryExpression, PrefixUnaryExpression, PostfixUnaryExpression, or ForInOrOfStatement that references

// the given node as an assignment target

func GetAssignmentTarget(node *Node) *Node {

for {

parent := node.Parent

switch parent.Kind {

case KindBinaryExpression:

if IsAssignmentOperator(parent.AsBinaryExpression().OperatorToken.Kind) && parent.AsBinaryExpression().Left == node {

return parent

}

return nil

case KindPrefixUnaryExpression:

if parent.AsPrefixUnaryExpression().Operator == KindPlusPlusToken || parent.AsPrefixUnaryExpression().Operator == KindMinusMinusToken {

return parent

}

return nil

case KindPostfixUnaryExpression:

if parent.AsPostfixUnaryExpression().Operator == KindPlusPlusToken || parent.AsPostfixUnaryExpression().Operator == KindMinusMinusToken {

return parent

}

return nil

case KindForInStatement, KindForOfStatement:

if parent.Initializer() == node {

return parent

}

return nil

case KindParenthesizedExpression, KindArrayLiteralExpression, KindSpreadElement, KindNonNullExpression:

node = parent

case KindSpreadAssignment:

node = parent.Parent

case KindShorthandPropertyAssignment:

if parent.AsShorthandPropertyAssignment().Name() != node {

return nil

}

node = parent.Parent

case KindPropertyAssignment:

if parent.AsPropertyAssignment().Name() == node {

return nil

}

node = parent.Parent

default:

return nil

}

}

}

func IsLogicalBinaryOperator(token Kind) bool {

return token == KindBarBarToken || token == KindAmpersandAmpersandToken

}

func IsLogicalOrCoalescingBinaryOperator(token Kind) bool {

return IsLogicalBinaryOperator(token) || token == KindQuestionQuestionToken

}

func IsLogicalOrCoalescingBinaryExpression(expr *Node) bool {

return IsBinaryExpression(expr) && IsLogicalOrCoalescingBinaryOperator(expr.AsBinaryExpression().OperatorToken.Kind)

}

func IsLogicalOrCoalescingAssignmentExpression(expr *Node) bool {

return IsBinaryExpression(expr) && IsLogicalOrCoalescingAssignmentOperator(expr.AsBinaryExpression().OperatorToken.Kind)

}

func IsLogicalExpression(node *Node) bool {

for {

if node.Kind == KindParenthesizedExpression {

node = node.Expression()

} else if node.Kind == KindPrefixUnaryExpression && node.AsPrefixUnaryExpression().Operator == KindExclamationToken {

node = node.AsPrefixUnaryExpression().Operand

} else {

return IsLogicalOrCoalescingBinaryExpression(node)

}

}

}

func IsAccessor(node *Node) bool {

return node.Kind == KindGetAccessor || node.Kind == KindSetAccessor

}

func IsPropertyNameLiteral(node *Node) bool {

switch node.Kind {

case KindIdentifier,

KindStringLiteral,

KindNoSubstitutionTemplateLiteral,

KindNumericLiteral:

return true

}

return false

}

func IsMemberName(node *Node) bool {

return node.Kind == KindIdentifier || node.Kind == KindPrivateIdentifier

}

func IsEntityName(node *Node) bool {

return node.Kind == KindIdentifier || node.Kind == KindQualifiedName

}

func IsPropertyName(node *Node) bool {

switch node.Kind {

case KindIdentifier,

KindPrivateIdentifier,

KindStringLiteral,

KindNumericLiteral,

KindComputedPropertyName:

return true

}

return false

}

// Return true if the given identifier is classified as an IdentifierName by inspecting the parent of the node

func IsIdentifierName(node *Node) bool {

parent := node.Parent

switch parent.Kind {

case KindPropertyDeclaration, KindPropertySignature, KindMethodDeclaration, KindMethodSignature, KindGetAccessor,

KindSetAccessor, KindEnumMember, KindPropertyAssignment, KindPropertyAccessExpression:

return parent.Name() == node

case KindQualifiedName:

return parent.AsQualifiedName().Right == node

case KindBindingElement:

return parent.PropertyName() == node

case KindImportSpecifier:

return parent.PropertyName() == node

case KindExportSpecifier, KindJsxAttribute, KindJsxSelfClosingElement, KindJsxOpeningElement, KindJsxClosingElement:

return true

}

return false

}

func IsPushOrUnshiftIdentifier(node *Node) bool {

text := node.Text()

return text == "push" || text == "unshift"

}

func IsBooleanLiteral(node *Node) bool {

return node.Kind == KindTrueKeyword || node.Kind == KindFalseKeyword

}

func IsLiteralExpression(node *Node) bool {

return IsLiteralKind(node.Kind)

}

func IsStringLiteralLike(node *Node) bool {

switch node.Kind {

case KindStringLiteral, KindNoSubstitutionTemplateLiteral:

return true

}

return false

}

func IsStringOrNumericLiteralLike(node *Node) bool {

return IsStringLiteralLike(node) || IsNumericLiteral(node)

}

func IsSignedNumericLiteral(node *Node) bool {

if node.Kind == KindPrefixUnaryExpression {

node := node.AsPrefixUnaryExpression()

return (node.Operator == KindPlusToken || node.Operator == KindMinusToken) && IsNumericLiteral(node.Operand)

}

return false

}

// Determines if a node is part of an OptionalChain

func IsOptionalChain(node *Node) bool {

if node.Flags&NodeFlagsOptionalChain != 0 {

switch node.Kind {

case KindPropertyAccessExpression,

KindElementAccessExpression,

KindCallExpression,

KindNonNullExpression:

return true

}

}

return false

}

func getQuestionDotToken(node *Expression) *TokenNode {

return node.QuestionDotToken()

}

// Determines if node is the root expression of an OptionalChain

func IsOptionalChainRoot(node *Expression) bool {

return IsOptionalChain(node) && !IsNonNullExpression(node) && getQuestionDotToken(node) != nil

}

// Determines whether a node is the outermost `OptionalChain` in an ECMAScript `OptionalExpression`:

//

// 1. For `a?.b.c`, the outermost chain is `a?.b.c` (`c` is the end of the chain starting at `a?.`)

// 2. For `a?.b!`, the outermost chain is `a?.b` (`b` is the end of the chain starting at `a?.`)

// 3. For `(a?.b.c).d`, the outermost chain is `a?.b.c` (`c` is the end of the chain starting at `a?.` since parens end the chain)

// 4. For `a?.b.c?.d`, both `a?.b.c` and `a?.b.c?.d` are outermost (`c` is the end of the chain starting at `a?.`, and `d` is

// the end of the chain starting at `c?.`)

// 5. For `a?.(b?.c).d`, both `b?.c` and `a?.(b?.c)d` are outermost (`c` is the end of the chain starting at `b`, and `d` is

// the end of the chain starting at `a?.`)

func IsOutermostOptionalChain(node *Expression) bool {

parent := node.Parent

return !IsOptionalChain(parent) || // cases 1, 2, and 3

IsOptionalChainRoot(parent) || // case 4

node != parent.Expression() // case 5

}

// Determines whether a node is the expression preceding an optional chain (i.e. `a` in `a?.b`).

func IsExpressionOfOptionalChainRoot(node *Node) bool {

return IsOptionalChainRoot(node.Parent) && node.Parent.Expression() == node

}

func IsNullishCoalesce(node *Node) bool {

return node.Kind == KindBinaryExpression && node.AsBinaryExpression().OperatorToken.Kind == KindQuestionQuestionToken

}

func IsAssertionExpression(node *Node) bool {

kind := node.Kind

return kind == KindTypeAssertionExpression || kind == KindAsExpression

}

func isLeftHandSideExpressionKind(kind Kind) bool {

switch kind {

case KindPropertyAccessExpression, KindElementAccessExpression, KindNewExpression, KindCallExpression,

KindJsxElement, KindJsxSelfClosingElement, KindJsxFragment, KindTaggedTemplateExpression, KindArrayLiteralExpression,

KindParenthesizedExpression, KindObjectLiteralExpression, KindClassExpression, KindFunctionExpression, KindIdentifier,

KindPrivateIdentifier, KindRegularExpressionLiteral, KindNumericLiteral, KindBigIntLiteral, KindStringLiteral,

KindNoSubstitutionTemplateLiteral, KindTemplateExpression, KindFalseKeyword, KindNullKeyword, KindThisKeyword,

KindTrueKeyword, KindSuperKeyword, KindNonNullExpression, KindExpressionWithTypeArguments, KindMetaProperty,

KindImportKeyword, KindMissingDeclaration:

return true

}

return false

}

// Determines whether a node is a LeftHandSideExpression based only on its kind.

func IsLeftHandSideExpression(node *Node) bool {

return isLeftHandSideExpressionKind(SkipPartiallyEmittedExpressions(node).Kind)

}

func isUnaryExpressionKind(kind Kind) bool {

switch kind {

case KindPrefixUnaryExpression,

KindPostfixUnaryExpression,

KindDeleteExpression,

KindTypeOfExpression,

KindVoidExpression,

KindAwaitExpression,

KindTypeAssertionExpression:

return true

}

return isLeftHandSideExpressionKind(kind)

}

// Determines whether a node is a UnaryExpression based only on its kind.

func IsUnaryExpression(node *Node) bool {

return isUnaryExpressionKind(SkipPartiallyEmittedExpressions(node).Kind)

}

func isExpressionKind(kind Kind) bool {

switch kind {

case KindConditionalExpression,

KindYieldExpression,

KindArrowFunction,

KindBinaryExpression,

KindSpreadElement,

KindAsExpression,

KindOmittedExpression,

KindPartiallyEmittedExpression,

KindSatisfiesExpression:

return true

}

return isUnaryExpressionKind(kind)

}

// Determines whether a node is an expression based only on its kind.

func IsExpression(node *Node) bool {

return isExpressionKind(SkipPartiallyEmittedExpressions(node).Kind)

}

func IsCommaExpression(node *Node) bool {

return node.Kind == KindBinaryExpression && node.AsBinaryExpression().OperatorToken.Kind == KindCommaToken

}

func IsCommaSequence(node *Node) bool {

return IsCommaExpression(node)

}

func IsIterationStatement(node *Node, lookInLabeledStatements bool) bool {

switch node.Kind {

case KindForStatement,

KindForInStatement,

KindForOfStatement,

KindDoStatement,

KindWhileStatement:

return true

case KindLabeledStatement:

return lookInLabeledStatements && IsIterationStatement(node.Statement(), lookInLabeledStatements)

}

return false

}

// Determines if a node is a property or element access expression

func IsAccessExpression(node *Node) bool {

return node.Kind == KindPropertyAccessExpression || node.Kind == KindElementAccessExpression

}

func isFunctionLikeDeclarationKind(kind Kind) bool {

switch kind {

case KindFunctionDeclaration,

KindMethodDeclaration,

KindConstructor,

KindGetAccessor,

KindSetAccessor,

KindFunctionExpression,

KindArrowFunction:

return true

}

return false

}

// Determines if a node is function-like (but is not a signature declaration)

func IsFunctionLikeDeclaration(node *Node) bool {

// TODO(rbuckton): Move `node != nil` test to call sites

return node != nil && isFunctionLikeDeclarationKind(node.Kind)

}

func IsFunctionLikeKind(kind Kind) bool {

switch kind {

case KindMethodSignature,

KindCallSignature,

KindJSDocSignature,

KindConstructSignature,

KindIndexSignature,

KindFunctionType,

KindConstructorType:

return true

}

return isFunctionLikeDeclarationKind(kind)

}

// Determines if a node is function- or signature-like.

func IsFunctionLike(node *Node) bool {

// TODO(rbuckton): Move `node != nil` test to call sites

return node != nil && IsFunctionLikeKind(node.Kind)

}

func IsFunctionLikeOrClassStaticBlockDeclaration(node *Node) bool {

return node != nil && (IsFunctionLike(node) || IsClassStaticBlockDeclaration(node))

}

func IsFunctionOrSourceFile(node *Node) bool {

return IsFunctionLike(node) || IsSourceFile(node)

}

func IsClassLike(node *Node) bool {

return node.Kind == KindClassDeclaration || node.Kind == KindClassExpression

}

func IsClassOrInterfaceLike(node *Node) bool {

return node.Kind == KindClassDeclaration || node.Kind == KindClassExpression || node.Kind == KindInterfaceDeclaration

}

func IsClassElement(node *Node) bool {

switch node.Kind {

case KindConstructor,

KindPropertyDeclaration,

KindMethodDeclaration,

KindGetAccessor,

KindSetAccessor,

KindIndexSignature,

KindClassStaticBlockDeclaration,

KindSemicolonClassElement:

return true

}

return false

}

func IsMethodOrAccessor(node *Node) bool {

switch node.Kind {

case KindMethodDeclaration, KindGetAccessor, KindSetAccessor:

return true

}

return false

}

func IsPrivateIdentifierClassElementDeclaration(node *Node) bool {

return (IsPropertyDeclaration(node) || IsMethodOrAccessor(node)) && IsPrivateIdentifier(node.Name())

}

func IsObjectLiteralOrClassExpressionMethodOrAccessor(node *Node) bool {

kind := node.Kind

return (kind == KindMethodDeclaration || kind == KindGetAccessor || kind == KindSetAccessor) &&

(node.Parent.Kind == KindObjectLiteralExpression || node.Parent.Kind == KindClassExpression)

}

func IsTypeElement(node *Node) bool {

switch node.Kind {

case KindConstructSignature,

KindCallSignature,

KindPropertySignature,

KindMethodSignature,

KindIndexSignature,

KindGetAccessor,

KindSetAccessor,

KindNotEmittedTypeElement:

return true

}

return false

}

func IsObjectLiteralElement(node *Node) bool {

switch node.Kind {

case KindPropertyAssignment,

KindShorthandPropertyAssignment,

KindSpreadAssignment,

KindMethodDeclaration,

KindGetAccessor,

KindSetAccessor:

return true

}

return false

}

func IsObjectLiteralMethod(node *Node) bool {

return node != nil && node.Kind == KindMethodDeclaration && node.Parent.Kind == KindObjectLiteralExpression

}

func IsAutoAccessorPropertyDeclaration(node *Node) bool {

return IsPropertyDeclaration(node) && HasAccessorModifier(node)

}

func IsParameterPropertyDeclaration(node *Node, parent *Node) bool {

return IsParameterDeclaration(node) && HasSyntacticModifier(node, ModifierFlagsParameterPropertyModifier) && parent.Kind == KindConstructor

}

func IsJsxChild(node *Node) bool {

switch node.Kind {

case KindJsxElement,

KindJsxExpression,

KindJsxSelfClosingElement,

KindJsxText,

KindJsxFragment:

return true

}

return false

}

func IsJsxAttributeLike(node *Node) bool {

return IsJsxAttribute(node) || IsJsxSpreadAttribute(node)

}

func isDeclarationStatementKind(kind Kind) bool {

switch kind {

case KindFunctionDeclaration,

KindMissingDeclaration,

KindClassDeclaration,

KindInterfaceDeclaration,

KindTypeAliasDeclaration,

KindJSTypeAliasDeclaration,

KindEnumDeclaration,

KindModuleDeclaration,

KindImportDeclaration,

KindJSImportDeclaration,

KindImportEqualsDeclaration,

KindExportDeclaration,

KindExportAssignment,

KindNamespaceExportDeclaration:

return true

}

return false

}

// Determines whether a node is a DeclarationStatement. Ideally this does not use Parent pointers, but it may use them

// to rule out a Block node that is part of `try` or `catch` or is the Block-like body of a function.

//

// NOTE: ECMA262 would just call this a Declaration

func IsDeclarationStatement(node *Node) bool {

return isDeclarationStatementKind(node.Kind)

}

func isStatementKindButNotDeclarationKind(kind Kind) bool {

switch kind {

case KindBreakStatement,

KindContinueStatement,

KindDebuggerStatement,

KindDoStatement,

KindExpressionStatement,

KindEmptyStatement,

KindForInStatement,

KindForOfStatement,

KindForStatement,

KindIfStatement,

KindLabeledStatement,

KindReturnStatement,

KindSwitchStatement,

KindThrowStatement,

KindTryStatement,

KindVariableStatement,

KindWhileStatement,

KindWithStatement,

KindNotEmittedStatement:

return true

}

return false

}

// Determines whether a node is a Statement that is not also a Declaration. Ideally this does not use Parent pointers,

// but it may use them to rule out a Block node that is part of `try` or `catch` or is the Block-like body of a function.

//

// NOTE: ECMA262 would just call this a Statement

func IsStatementButNotDeclaration(node *Node) bool {

return isStatementKindButNotDeclarationKind(node.Kind)

}

// Determines whether a node is a Statement. Ideally this does not use Parent pointers, but it may use

// them to rule out a Block node that is part of `try` or `catch` or is the Block-like body of a function.

//

// NOTE: ECMA262 would call this either a StatementListItem or ModuleListItem

func IsStatement(node *Node) bool {

kind := node.Kind

return isStatementKindButNotDeclarationKind(kind) || isDeclarationStatementKind(kind) || isBlockStatement(node)

}

// Determines whether a node is a BlockStatement. If parents are available, this ensures the Block is

// not part of a `try` statement, `catch` clause, or the Block-like body of a function

func isBlockStatement(node *Node) bool {

if node.Kind != KindBlock {

return false

}

if node.Parent != nil && (node.Parent.Kind == KindTryStatement || node.Parent.Kind == KindCatchClause) {

return false

}

return !IsFunctionBlock(node)

}

// Determines whether a node is the Block-like body of a function by walking the parent of the node

func IsFunctionBlock(node *Node) bool {

return node != nil && node.Kind == KindBlock && node.Parent != nil && IsFunctionLike(node.Parent)

}

func IsBlockOrCatchScoped(declaration *Node) bool {

return GetCombinedNodeFlags(declaration)&NodeFlagsBlockScoped != 0 || IsCatchClauseVariableDeclarationOrBindingElement(declaration)

}

func IsCatchClauseVariableDeclarationOrBindingElement(declaration *Node) bool {

node := GetRootDeclaration(declaration)

return node.Kind == KindVariableDeclaration && node.Parent.Kind == KindCatchClause

}

func IsTypeNodeKind(kind Kind) bool {

switch kind {

case KindAnyKeyword,

KindUnknownKeyword,

KindNumberKeyword,

KindBigIntKeyword,

KindObjectKeyword,

KindBooleanKeyword,

KindStringKeyword,

KindSymbolKeyword,

KindVoidKeyword,

KindUndefinedKeyword,

KindNeverKeyword,

KindIntrinsicKeyword,

KindExpressionWithTypeArguments,

KindJSDocAllType,

KindJSDocNullableType,

KindJSDocNonNullableType,

KindJSDocOptionalType,

KindJSDocVariadicType:

return true

}

return kind >= KindFirstTypeNode && kind <= KindLastTypeNode

}

func IsTypeNode(node *Node) bool {

return IsTypeNodeKind(node.Kind)

}

func IsJSDocKind(kind Kind) bool {

return KindFirstJSDocNode <= kind && kind <= KindLastJSDocNode

}

func IsJSDocTypeAssertion(node *Node) bool {

if node == nil || !IsParenthesizedExpression(node) || !IsInJSFile(node) {

return false

}

expr := node.Expression()

return IsAsExpression(expr) && expr.Type() != nil && expr.Type().Flags&NodeFlagsReparsed != 0

}

func IsPrologueDirective(node *Node) bool {

return node.Kind == KindExpressionStatement &&

node.Expression().Kind == KindStringLiteral

}

type OuterExpressionKinds uint16

const (

OEKParentheses OuterExpressionKinds = 1 << 0

OEKTypeAssertions OuterExpressionKinds = 1 << 1

OEKNonNullAssertions OuterExpressionKinds = 1 << 2

OEKPartiallyEmittedExpressions OuterExpressionKinds = 1 << 3

OEKExpressionsWithTypeArguments OuterExpressionKinds = 1 << 4

OEKSatisfies OuterExpressionKinds = 1 << 5

OEKExcludeJSDocTypeAssertion OuterExpressionKinds = 1 << 6

OEKAssignments OuterExpressionKinds = 1 << 7

OEKComma OuterExpressionKinds = 1 << 8

OEKAssertions = OEKTypeAssertions | OEKNonNullAssertions | OEKSatisfies

OEKAll = OEKParentheses | OEKAssertions | OEKPartiallyEmittedExpressions | OEKExpressionsWithTypeArguments

OEKAllExceptAssertionsOrExpressionsWithTypeArguments = OEKAll &^ OEKAssertions &^ OEKExpressionsWithTypeArguments

OEKExpressionTypePassthrough = OEKParentheses | OEKAssignments | OEKComma

)

// Determines whether node is an "outer expression" of the provided kinds

func IsOuterExpression(node *Expression, kinds OuterExpressionKinds) bool {

switch node.Kind {

case KindParenthesizedExpression:

return kinds&OEKParentheses != 0 && !(kinds&OEKExcludeJSDocTypeAssertion != 0 && IsJSDocTypeAssertion(node))

case KindTypeAssertionExpression, KindAsExpression:

return kinds&OEKTypeAssertions != 0

case KindSatisfiesExpression:

return kinds&(OEKExpressionsWithTypeArguments|OEKSatisfies) != 0

case KindExpressionWithTypeArguments:

return kinds&OEKExpressionsWithTypeArguments != 0

case KindNonNullExpression:

return kinds&OEKNonNullAssertions != 0

case KindPartiallyEmittedExpression:

return kinds&OEKPartiallyEmittedExpressions != 0

case KindBinaryExpression:

switch node.AsBinaryExpression().OperatorToken.Kind {

case KindEqualsToken:

return kinds&OEKAssignments != 0

case KindCommaToken:

return kinds&OEKComma != 0

}

}

return false

}

// Descends into an expression, skipping past "outer expressions" of the provided kinds

func SkipOuterExpressions(node *Expression, kinds OuterExpressionKinds) *Expression {

for IsOuterExpression(node, kinds) {

if IsBinaryExpression(node) {

node = node.AsBinaryExpression().Right

} else {

node = node.Expression()

}

}

return node

}

// Skips past the parentheses of an expression

func SkipParentheses(node *Expression) *Expression {

return SkipOuterExpressions(node, OEKParentheses)

}

func SkipTypeParentheses(node *Node) *Node {

for IsParenthesizedTypeNode(node) {

node = node.Type()

}

return node

}

func SkipPartiallyEmittedExpressions(node *Expression) *Expression {

return SkipOuterExpressions(node, OEKPartiallyEmittedExpressions)

}

// Walks up the parents of a parenthesized expression to find the containing node

func WalkUpParenthesizedExpressions(node *Expression) *Node {

for node != nil && node.Kind == KindParenthesizedExpression {

node = node.Parent

}

return node

}

// Walks up the parents of a parenthesized type to find the containing node

func WalkUpParenthesizedTypes(node *TypeNode) *Node {

for node != nil && node.Kind == KindParenthesizedType {

node = node.Parent

}

return node

}

// Walks up the parents of a node to find the containing SourceFile

func GetSourceFileOfNode(node *Node) *SourceFile {

for node != nil {

if node.Kind == KindSourceFile {

return node.AsSourceFile()

}

node = node.Parent

}

return nil

}

var setParentInChildrenPool = sync.Pool{

New: func() any {

return newParentInChildrenSetter()

},

}

func newParentInChildrenSetter() func(node *Node) bool {

// Consolidate state into one allocation.

// Similar to https://go.dev/cl/552375.

var state struct {

parent *Node

visit func(*Node) bool

}

state.visit = func(node *Node) bool {

if state.parent != nil {

node.Parent = state.parent

}

saveParent := state.parent

state.parent = node

node.ForEachChild(state.visit)

state.parent = saveParent

return false

}

return state.visit

}

func SetParentInChildren(node *Node) {

fn := setParentInChildrenPool.Get().(func(node *Node) bool)

defer setParentInChildrenPool.Put(fn)

fn(node)

}

// This should never be called outside the parser

func SetImportsOfSourceFile(node *SourceFile, imports []*LiteralLikeNode) {

node.imports = imports

}

// Walks up the parents of a node to find the ancestor that matches the callback

func FindAncestor(node *Node, callback func(*Node) bool) *Node {

for node != nil {

if callback(node) {

return node

}

node = node.Parent

}

return nil

}

func FindManyAncestors(node *Node, callbacks ...func(*Node) bool) []*Node {

ancestors := make([]*Node, len(callbacks))

found := 0

for node != nil {

for i, callback := range callbacks {

if ancestors[i] == nil && callback(node) {

ancestors[i] = node

found++

if found == len(callbacks) {

return ancestors

}

break

}

}

node = node.Parent

}

return ancestors

}

// Walks up the parents of a node to find the ancestor that matches the kind

func FindAncestorKind(node *Node, kind Kind) *Node {

for node != nil {

if node.Kind == kind {

return node

}

node = node.Parent

}

return nil

}

type FindAncestorResult int32