public SwitchStatement VisitSwitchStatement(SwitchStatement node)
{
theSwitch = node;
CheckAndModifyCondition();
ChangeCasesLabel();
return node;
}
public void FixCases(SwitchStatement theSwitch)
{
DefaultCase defaultCase = theSwitch.Cases.LastOrDefault() as DefaultCase;
StatementType defaultCaseStatementType = StatementType.None;
string defaultCaseGotoLabel = null;
if (defaultCase != null && !TryGetSimpleCaseStatementType(defaultCase, out defaultCaseStatementType, out defaultCaseGotoLabel))
{
return;
}
HashSet<SwitchCase> casesToRemove = new HashSet<SwitchCase>();
List<SwitchCase> allCases = new List<SwitchCase>(theSwitch.Cases);
foreach (SwitchCase @case in allCases)
{
if (@case == defaultCase)
{
break;
}
if (@case.Body == null)
{
casesToRemove.Add(@case);
continue;
}
StatementType caseStatementType;
string caseGotoLabel;
if (TryGetSimpleCaseStatementType(@case, out caseStatementType, out caseGotoLabel))
{
if (defaultCase != null)
{
if (defaultCaseStatementType == caseStatementType && defaultCaseGotoLabel == caseGotoLabel)
{
casesToRemove.Add(@case);
break;
}
}
else
{
if (caseStatementType == StatementType.Break)
{
casesToRemove.Add(@case);
break;
}
}
}
casesToRemove.Clear();
}
if (casesToRemove.Count > 0)
{
theSwitch.Cases = allCases.Where(@case => !casesToRemove.Contains(@case));
}
}
public override ICodeNode VisitSwitchStatement(SwitchStatement node)
{
node.Condition = (Expression)Visit(node.Condition);
foreach (SwitchCase @case in node.Cases)
{
if (@case is ConditionCase)
{
ConditionCase conditionCase = @case as ConditionCase;
if (NeedsCast(conditionCase.Condition.ExpressionType, node.Condition.ExpressionType))
{
if (conditionCase.Condition is LiteralExpression)
{
conditionCase.Condition = EnumHelper.GetEnumExpression(node.Condition.ExpressionType.Resolve(),
(conditionCase.Condition as LiteralExpression), typeSystem);
}
else
{
conditionCase.Condition = new CastExpression(conditionCase.Condition, node.Condition.ExpressionType, null);
}
}
}
}
node = (SwitchStatement)base.VisitSwitchStatement(node);
return node;
}
public override void VisitSwitchStatement(SwitchStatement node)
{
return;
}
public override ICodeNode VisitSwitchStatement(SwitchStatement node)
{
fixSwitchCasesStep.FixCases(node);
return base.VisitSwitchStatement(fixSwitchConditionStep.VisitSwitchStatement(node));
}
public override void VisitSwitchStatement(SwitchStatement node)
{
loopStates.Push(StatementState.Switch);
WriteKeyword(KeyWordWriter.Switch);
WriteSpace();
WriteKeyword(KeyWordWriter.Case);
WriteSpace();
Visit(node.Condition);
WriteLine();
WriteBlock(() => VisitVBSwitchCases(node.Cases), "");
WriteEndBlock(KeyWordWriter.Switch);
loopStates.Pop();
}
public override void VisitSwitchStatement(SwitchStatement node)
{
TryProcessConditionStatement(node);
states.Push(Step.Expression);
Visit(node.Condition);
states.Pop();
Visit(node.Cases);
}
/// <summary>
/// Resolves the type of the switch variable.
/// </summary>
/// <param name="switchStatement">The switch statement.</param>
/// <returns>Returns TypeReference to the type of the switch variable.</returns>
private TypeReference GetSwitchType(SwitchStatement switchStatement)
{
/// switchStatement.Cases.First() without LINQ.
ConditionCase cc = null;
IEnumerable<SwitchCase> cases = switchStatement.Cases;
foreach (SwitchCase @case in cases)
{
if (@case is ConditionCase)
{
cc = @case as ConditionCase;
break;
}
}
LiteralExpression condition = cc.Condition as LiteralExpression;
if (condition == null)
{
throw new NotSupportedException("Case should have literal condition.");
}
TypeReference result = condition.ExpressionType;
return result;
}
public override void VisitSwitchStatement(SwitchStatement node)
{
WriteKeyword(KeyWordWriter.Switch);
WriteSpace();
WriteToken("(");
Visit(node.Condition);
WriteToken(")");
WriteLine();
WriteBlock(() =>
{
Visit(node.Cases);
WriteLine();
}
, "");
}
public virtual void VisitSwitchStatement(SwitchStatement node)
{
Visit(node.Condition);
Visit(node.Cases);
}