private void checkDefault(SwitchLabelContext label, Expression caseExpression, ref bool hasDefault)
 {
     if (caseExpression == null)
     {
         if (hasDefault)
         {
             log.error(
                 new DiagnosticPosition(label.start.Line, label.start.Column),
                 messages.multipleDefaults);
         }
         hasDefault = true;
     }
 }
        private Switch makeSwitch(StatementContext stat)
        {
            Expression selector = (Expression)VisitExpression(stat.expression());

            CaseGroupContext[]         caseGroups   = stat.caseGroup();
            IList <SwitchLabelContext> bottomLabels = stat._bottomLabels;

            int count = caseGroups.Select(x => x.labels._labels.Count).Sum();

            Case[] cases = new Case[count + bottomLabels.Count];

            int  iCases     = 0;
            bool hasDefault = false;

            foreach (CaseGroupContext caseGroup in caseGroups)
            {
                IList <SwitchLabelContext> labels = caseGroup.labels._labels;
                int last = labels.Count - 1;
                // for each label except last
                for (var index = 0; index < last; index++)
                {
                    SwitchLabelContext label          = labels[index];
                    Expression         caseExpression = getCaseExpression(label);
                    checkDefault(label, caseExpression, ref hasDefault);
                    cases[iCases++] = new Case(label.start.Line, label.start.Column, label.stop.Line,
                                               label.stop.Column, caseExpression,
                                               CollectionUtils.emptyList <StatementNode>());
                }
                SwitchLabelContext lastLabel          = labels[last];
                Expression         lastCaseExpression = getCaseExpression(lastLabel);
                checkDefault(lastLabel, lastCaseExpression, ref hasDefault);
                IList <StatementNode> statements = convertBlockStatementList(caseGroup.stmts);

                cases[iCases++] = new Case(lastLabel.start.Line, lastLabel.start.Column, caseGroup.stop.Line,
                                           caseGroup.stop.Column, lastCaseExpression, statements);
            }

            foreach (SwitchLabelContext label in bottomLabels)
            {
                Expression caseExpression = getCaseExpression(label);
                checkDefault(label, caseExpression, ref hasDefault);
                cases[iCases++] = new Case(label.start.Line, label.start.Column, label.stop.Line,
                                           label.stop.Column, caseExpression,
                                           CollectionUtils.emptyList <StatementNode>());
            }

            return(new Switch(stat.start.Line, stat.start.Column, stat.stop.Line,
                              stat.stop.Column, selector, cases, hasDefault));
        }
        protected virtual bool VisitSwitchLabel(SwitchLabelContext ctx)
        {
            var expr = ctx.constantExpression();

            if (expr != null)
            {
                var exprText = expr.GetText();
                if (ResizingBehaviorEnum.Contains(exprText))
                {
                    _rewriter.Replace(expr.Start, expr.Stop, $"ResizingBehavior.{exprText}");
                }
            }

            return(true);
        }
 public override Tree VisitSwitchLabel(SwitchLabelContext context) => throw new InvalidOperationException();
        private Expression getCaseExpression(SwitchLabelContext label)
        {
            ConstantExpressionContext constExp = label.constantExpression();

            return(constExp == null ? null : (Expression)VisitLiteral(constExp.literal()));
        }