public override List <Diagnostic> VisitSwitchCaseBody([NotNull] LGFileParser.SwitchCaseBodyContext context)
            {
                var result          = new List <Diagnostic>();
                var switchCaseRules = context.switchCaseTemplateBody().switchCaseRule();
                var length          = switchCaseRules.Length;

                for (var idx = 0; idx < length; idx++)
                {
                    var switchCaseNode = switchCaseRules[idx].switchCaseStat();
                    var switchExpr     = switchCaseNode.SWITCH() != null;
                    var caseExpr       = switchCaseNode.CASE() != null;
                    var defaultExpr    = switchCaseNode.DEFAULT() != null;
                    var node           = switchExpr ? switchCaseNode.SWITCH() :
                                         caseExpr?switchCaseNode.CASE() :
                                             switchCaseNode.DEFAULT();

                    if (node.GetText().Count(u => u == ' ') > 1)
                    {
                        result.Add(BuildLGDiagnostic($"At most 1 whitespace is allowed between SWITCH/CASE/DEFAULT and :.", context: switchCaseNode));
                    }

                    if (idx == 0 && !switchExpr)
                    {
                        result.Add(BuildLGDiagnostic($"control flow is not start with switch", context: switchCaseNode));
                    }

                    if (idx > 0 && switchExpr)
                    {
                        result.Add(BuildLGDiagnostic($"control flow can not have more than one switch statement", context: switchCaseNode));
                    }

                    if (idx > 0 && idx < length - 1 && !caseExpr)
                    {
                        result.Add(BuildLGDiagnostic($"only case statement is allowed in the middle of control flow", context: switchCaseNode));
                    }

                    if (idx == length - 1 && (caseExpr || defaultExpr))
                    {
                        if (caseExpr)
                        {
                            result.Add(BuildLGDiagnostic($"control flow is not ending with default statement", DiagnosticSeverity.Warning, switchCaseNode));
                        }
                        else
                        {
                            if (length == 2)
                            {
                                result.Add(BuildLGDiagnostic($"control flow should have at least one case statement", DiagnosticSeverity.Warning, switchCaseNode));
                            }
                        }
                    }

                    if (switchExpr || caseExpr)
                    {
                        if (switchCaseNode.EXPRESSION().Length != 1)
                        {
                            result.Add(BuildLGDiagnostic($"switch and case should followed by one valid expression", context: switchCaseNode));
                        }
                        else
                        {
                            result.AddRange(CheckExpression(switchCaseNode.EXPRESSION(0).GetText(), switchCaseNode));
                        }
                    }
                    else
                    {
                        if (switchCaseNode.EXPRESSION().Length != 0 || switchCaseNode.TEXT().Length != 0)
                        {
                            result.Add(BuildLGDiagnostic($"default should not followed by any expression or any text", context: switchCaseNode));
                        }
                    }

                    if (caseExpr || defaultExpr)
                    {
                        if (switchCaseRules[idx].normalTemplateBody() != null)
                        {
                            result.AddRange(Visit(switchCaseRules[idx].normalTemplateBody()));
                        }
                        else
                        {
                            result.Add(BuildLGDiagnostic($"no normal template body in case or default block", context: switchCaseNode));
                        }
                    }
                }

                return(result);
            }
        public override List <Diagnostic> VisitSwitchCaseBody([NotNull] LGFileParser.SwitchCaseBodyContext context)
        {
            var result          = new List <Diagnostic>();
            var switchCaseRules = context.switchCaseTemplateBody().switchCaseRule();
            var length          = switchCaseRules.Length;

            for (var idx = 0; idx < length; idx++)
            {
                var switchCaseNode = switchCaseRules[idx].switchCaseStat();
                var switchExpr     = switchCaseNode.SWITCH() != null;
                var caseExpr       = switchCaseNode.CASE() != null;
                var defaultExpr    = switchCaseNode.DEFAULT() != null;
                var node           = switchExpr ? switchCaseNode.SWITCH() :
                                     caseExpr?switchCaseNode.CASE() :
                                         switchCaseNode.DEFAULT();

                if (node.GetText().Count(u => u == ' ') > 1)
                {
                    result.Add(BuildLGDiagnostic(LGErrors.InvalidWhitespaceInSwitchCase, context: switchCaseNode));
                }

                if (idx == 0 && !switchExpr)
                {
                    result.Add(BuildLGDiagnostic(LGErrors.NotStartWithSwitchInSwitchCase, context: switchCaseNode));
                }

                if (idx > 0 && switchExpr)
                {
                    result.Add(BuildLGDiagnostic(LGErrors.MultipleSwithStatementInSwitchCase, context: switchCaseNode));
                }

                if (idx > 0 && idx < length - 1 && !caseExpr)
                {
                    result.Add(BuildLGDiagnostic(LGErrors.InvalidStatementInMiddlerOfSwitchCase, context: switchCaseNode));
                }

                if (idx == length - 1 && (caseExpr || defaultExpr))
                {
                    if (caseExpr)
                    {
                        result.Add(BuildLGDiagnostic(LGErrors.NotEndWithDefaultInSwitchCase, DiagnosticSeverity.Warning, switchCaseNode));
                    }
                    else
                    {
                        if (length == 2)
                        {
                            result.Add(BuildLGDiagnostic(LGErrors.MissingCaseInSwitchCase, DiagnosticSeverity.Warning, switchCaseNode));
                        }
                    }
                }

                if (switchExpr || caseExpr)
                {
                    if (switchCaseNode.EXPRESSION().Length != 1)
                    {
                        result.Add(BuildLGDiagnostic(LGErrors.InvalidExpressionInSwiathCase, context: switchCaseNode));
                    }
                    else
                    {
                        var errorPrefix = switchExpr ? "Switch" : "Case";
                        errorPrefix += " '" + switchCaseNode.EXPRESSION(0).GetText() + "': ";
                        result.AddRange(CheckExpression(switchCaseNode.EXPRESSION(0).GetText(), switchCaseNode, errorPrefix));
                    }
                }
                else
                {
                    if (switchCaseNode.EXPRESSION().Length != 0 || switchCaseNode.TEXT().Length != 0)
                    {
                        result.Add(BuildLGDiagnostic(LGErrors.ExtraExpressionInSwitchCase, context: switchCaseNode));
                    }
                }

                if (caseExpr || defaultExpr)
                {
                    if (switchCaseRules[idx].normalTemplateBody() != null)
                    {
                        result.AddRange(Visit(switchCaseRules[idx].normalTemplateBody()));
                    }
                    else
                    {
                        result.Add(BuildLGDiagnostic(LGErrors.MissingTemplateBodyInSwitchCase, context: switchCaseNode));
                    }
                }
            }

            return(result);
        }