Function isPartOfTypeNode

test/fixtures/snapshot/typescript.js:15516–15607

(node)

    ts.fullTripleSlashAMDReferencePathRegEx = /^(\/\/\/\s*<amd-dependency\s+path\s*=\s*)(('[^']*')|("[^"]*")).*?\/>/;
    var defaultLibReferenceRegEx = /^(\/\/\/\s*<reference\s+no-default-lib\s*=\s*)(('[^']*')|("[^"]*"))\s*\/>/;
    function isPartOfTypeNode(node) {
        if (177 /* SyntaxKind.FirstTypeNode */ <= node.kind && node.kind <= 200 /* SyntaxKind.LastTypeNode */) {
            return true;
        }
        switch (node.kind) {
            case 130 /* SyntaxKind.AnyKeyword */:
            case 155 /* SyntaxKind.UnknownKeyword */:
            case 147 /* SyntaxKind.NumberKeyword */:
            case 158 /* SyntaxKind.BigIntKeyword */:
            case 150 /* SyntaxKind.StringKeyword */:
            case 133 /* SyntaxKind.BooleanKeyword */:
            case 151 /* SyntaxKind.SymbolKeyword */:
            case 148 /* SyntaxKind.ObjectKeyword */:
            case 153 /* SyntaxKind.UndefinedKeyword */:
            case 143 /* SyntaxKind.NeverKeyword */:
                return true;
            case 114 /* SyntaxKind.VoidKeyword */:
                return node.parent.kind !== 217 /* SyntaxKind.VoidExpression */;
            case 228 /* SyntaxKind.ExpressionWithTypeArguments */:
                return ts.isHeritageClause(node.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(node);
            case 163 /* SyntaxKind.TypeParameter */:
                return node.parent.kind === 195 /* SyntaxKind.MappedType */ || node.parent.kind === 190 /* SyntaxKind.InferType */;
            // Identifiers and qualified names may be type nodes, depending on their context. Climb
            // above them to find the lowest container
            case 79 /* SyntaxKind.Identifier */:
                // If the identifier is the RHS of a qualified name, then it's a type iff its parent is.
                if (node.parent.kind === 161 /* SyntaxKind.QualifiedName */ && node.parent.right === node) {
                    node = node.parent;
                }
                else if (node.parent.kind === 206 /* SyntaxKind.PropertyAccessExpression */ && node.parent.name === node) {
                    node = node.parent;
                }
                // At this point, node is either a qualified name or an identifier
                ts.Debug.assert(node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 161 /* SyntaxKind.QualifiedName */ || node.kind === 206 /* SyntaxKind.PropertyAccessExpression */, "'node' was expected to be a qualified name, identifier or property access in 'isPartOfTypeNode'.");
            // falls through
            case 161 /* SyntaxKind.QualifiedName */:
            case 206 /* SyntaxKind.PropertyAccessExpression */:
            case 108 /* SyntaxKind.ThisKeyword */: {
                var parent = node.parent;
                if (parent.kind === 181 /* SyntaxKind.TypeQuery */) {
                    return false;
                }
                if (parent.kind === 200 /* SyntaxKind.ImportType */) {
                    return !parent.isTypeOf;
                }
                // Do not recursively call isPartOfTypeNode on the parent. In the example:
                //
                //     let a: A.B.C;
                //
                // Calling isPartOfTypeNode would consider the qualified name A.B a type node.
                // Only C and A.B.C are type nodes.
                if (177 /* SyntaxKind.FirstTypeNode */ <= parent.kind && parent.kind <= 200 /* SyntaxKind.LastTypeNode */) {
                    return true;
                }
                switch (parent.kind) {
                    case 228 /* SyntaxKind.ExpressionWithTypeArguments */:
                        return ts.isHeritageClause(parent.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(parent);
                    case 163 /* SyntaxKind.TypeParameter */: