public static bool IsExpression()

in Public/Src/FrontEnd/TypeScript.Net/TypeScript.Net/Types/NodeUtilities.cs [906:1035]
120 lines of code
76 McCabe index (conditional complexity)

        public static bool IsExpression(INode node)
        {
            switch (node.Kind)
            {
                case SyntaxKind.SuperKeyword:
                case SyntaxKind.NullKeyword:
                case SyntaxKind.TrueKeyword:
                case SyntaxKind.FalseKeyword:
                case SyntaxKind.RegularExpressionLiteral:
                case SyntaxKind.ArrayLiteralExpression:
                case SyntaxKind.ObjectLiteralExpression:
                case SyntaxKind.PropertyAccessExpression:
                case SyntaxKind.ElementAccessExpression:
                case SyntaxKind.CallExpression:
                case SyntaxKind.NewExpression:
                case SyntaxKind.TaggedTemplateExpression:
                case SyntaxKind.AsExpression:
                case SyntaxKind.TypeAssertionExpression:
                case SyntaxKind.ParenthesizedExpression:
                case SyntaxKind.FunctionExpression:
                case SyntaxKind.ClassExpression:
                case SyntaxKind.ArrowFunction:
                case SyntaxKind.VoidExpression:
                case SyntaxKind.DeleteExpression:
                case SyntaxKind.TypeOfExpression:
                case SyntaxKind.PrefixUnaryExpression:
                case SyntaxKind.PostfixUnaryExpression:
                case SyntaxKind.BinaryExpression:
                case SyntaxKind.ConditionalExpression:
                case SyntaxKind.SwitchExpression:
                case SyntaxKind.SwitchExpressionClause:
                case SyntaxKind.SpreadElementExpression:
                case SyntaxKind.TemplateExpression:
                case SyntaxKind.NoSubstitutionTemplateLiteral:
                case SyntaxKind.OmittedExpression:
                case SyntaxKind.YieldExpression:
                case SyntaxKind.AwaitExpression:
                    return true;
                case SyntaxKind.QualifiedName:
                    while (node.Parent.Kind == SyntaxKind.QualifiedName)
                    {
                        node = node.Parent;
                    }

                    return node.Parent.Kind == SyntaxKind.TypeQuery;
                case SyntaxKind.Identifier:
                    {
                        if (node.Parent.Kind == SyntaxKind.TypeQuery)
                        {
                            return true;
                        }

                        goto case SyntaxKind.NumericLiteral;
                    }

                // fall through
                case SyntaxKind.NumericLiteral:
                case SyntaxKind.StringLiteral:
                case SyntaxKind.ThisKeyword:
                    {
                        var parent = node.Parent;
                        switch (parent.Kind)
                        {
                            case SyntaxKind.VariableDeclaration:
                            case SyntaxKind.Parameter:
                            case SyntaxKind.PropertyDeclaration:
                            case SyntaxKind.PropertySignature:
                            case SyntaxKind.EnumMember:
                            case SyntaxKind.PropertyAssignment:
                            case SyntaxKind.BindingElement:
                                return parent.Cast<IVariableLikeDeclaration>().Initializer.ResolveUnionType() == node.ResolveUnionType();
                            case SyntaxKind.ExpressionStatement:
                            case SyntaxKind.IfStatement:
                            case SyntaxKind.DoStatement:
                            case SyntaxKind.WhileStatement:
                            case SyntaxKind.ReturnStatement:
                            case SyntaxKind.WithStatement:
                            case SyntaxKind.CaseClause:
                            case SyntaxKind.ThrowStatement:
                            case SyntaxKind.SwitchStatement:
                                return parent.Cast<IExpressionStatement>().Expression.ResolveUnionType() == node.ResolveUnionType();
                            case SyntaxKind.ForStatement:
                                {
                                    var forStatement = parent.Cast<IForStatement>();
                                    INode initializer = forStatement.Initializer;
                                    return (initializer.ResolveUnionType() == node.ResolveUnionType() && initializer.Kind != SyntaxKind.VariableDeclarationList)
                                           || forStatement.Condition.ResolveUnionType() == node.ResolveUnionType() || forStatement.Incrementor.ResolveUnionType() == node.ResolveUnionType();
                                }

                            case SyntaxKind.ForInStatement:
                                {
                                    var forInStatement = parent.Cast<IForInStatement>();
                                    return (forInStatement.Initializer.ResolveUnionType() == node.ResolveUnionType() && forInStatement.Initializer.Kind != SyntaxKind.VariableDeclarationList) ||
                                           forInStatement.Expression.ResolveUnionType() == node.ResolveUnionType();
                                }

                            case SyntaxKind.ForOfStatement:
                                {
                                    var forInStatement = parent.Cast<IForOfStatement>();
                                    return (forInStatement.Initializer.ResolveUnionType() == node.ResolveUnionType() && forInStatement.Initializer.Kind != SyntaxKind.VariableDeclarationList) ||
                                           forInStatement.Expression.ResolveUnionType() == node.ResolveUnionType();
                                }

                            case SyntaxKind.TypeAssertionExpression:
                                return node.ResolveUnionType() == parent.Cast<ITypeAssertion>().Expression.ResolveUnionType();
                            case SyntaxKind.AsExpression:
                                return node.ResolveUnionType() == parent.Cast<IAsExpression>().Expression.ResolveUnionType();
                            case SyntaxKind.TemplateSpan:
                                return node.ResolveUnionType() == parent.Cast<ITemplateSpan>().Expression.ResolveUnionType();
                            case SyntaxKind.ComputedPropertyName:
                                return node.ResolveUnionType() == parent.Cast<IComputedPropertyName>().Expression.ResolveUnionType();
                            case SyntaxKind.Decorator:
                                return true;
                            case SyntaxKind.ExpressionWithTypeArguments:
                                return parent.Cast<IExpressionWithTypeArguments>().Expression.ResolveUnionType() == node.ResolveUnionType() && IsExpressionWithTypeArgumentsInClassExtendsClause(parent);
                            default:
                                if (IsExpression(parent))
                                {
                                    return true;
                                }

                                break;
                        }
                    }

                    break;
            }

            return false;
        }