public static string SwitchSection(SwitchSectionSyntax section)
{
var output = section.Labels.Aggregate("", (current, label) => current + SyntaxNode(label));
return section.Statements.TakeWhile(statement => !(statement is BreakStatementSyntax)) // Swift doesn't use break; statements.
.Aggregate(output, (current, statement) => current + (" " + SyntaxNode(statement))); //TODO: Handle case/switch indenting in Indenter.cs
}
public override void VisitSwitchSection(SwitchSectionSyntax node)
{
foreach (var label in node.Labels)
{
var match = label as CasePatternSwitchLabelSyntax;
if (match != null)
{
Visit(match.Pattern);
if (match.WhenClause != null)
{
Visit(match.WhenClause.Condition);
}
}
}
}
internal static bool HasBraces(SwitchSectionSyntax section)
{
switch (section.Statements.Count)
{
case 1:
if (section.Statements.First() is BlockSyntax)
return true;
break;
case 2:
if (section.Statements.First() is BlockSyntax && section.Statements.Last() is BreakStatementSyntax)
return true;
break;
}
return false;
}
static SwitchSectionSyntax CreateNewSection(SwitchSectionSyntax section)
{
SyntaxList <StatementSyntax> statements = section.GetStatements();
if (statements.Last().IsKind(SyntaxKind.ThrowStatement))
{
return(section);
}
var expressionStatement = (ExpressionStatementSyntax)statements.LastButOne();
var assignment = (AssignmentExpressionSyntax)expressionStatement.Expression;
section = section.ReplaceNode(expressionStatement, ReturnStatement(assignment.Right).WithTriviaFrom(expressionStatement));
return(section.RemoveStatement(section.GetStatements().Last()));
}
public static bool CanAddBraces(SwitchSectionSyntax section)
{
SyntaxList <StatementSyntax> statements = section.Statements;
if (statements.Count > 1)
{
return(true);
}
else if (statements.Count == 1 && statements[0].Kind() != SyntaxKind.Block)
{
return(true);
}
else
{
return(false);
}
}
public static async Task <Document> RefactorAsync(
Document document,
SwitchSectionSyntax switchSection,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
SwitchSectionSyntax newNode = switchSection
.WithStatements(
List <StatementSyntax>(
SingletonList(
Block(switchSection.Statements))))
.WithFormatterAnnotation();
SyntaxNode newRoot = root.ReplaceNode(switchSection, newNode);
return(document.WithSyntaxRoot(newRoot));
}
private static bool IsEmptyOrContainsOnlyDefaultSection(SwitchStatementSyntax switchStatement)
{
if (switchStatement.Sections.Count == 0)
{
return(true);
}
else if (switchStatement.Sections.Count == 1)
{
SwitchSectionSyntax section = switchStatement.Sections[0];
return(section.Labels.Count == 1 &&
section.Labels[0].IsKind(SyntaxKind.DefaultSwitchLabel));
}
else
{
return(false);
}
}
public override SyntaxNode VisitSwitchSection(SwitchSectionSyntax node)
{
node = (SwitchSectionSyntax)base.VisitSwitchSection(node);
var oldStatements = node.Statements;
if (oldStatements.Count == 0) //empty case - used for fall-through
{
return(node);
}
var caseTrailing = node.GetTrailingTrivia();
var caseLeading = node.GetLeadingTrivia();
var trueBlock = ToBlockSyntax(oldStatements, caseLeading, caseTrailing);
node = node.WithStatements(trueBlock);
return(node);
}
public override void VisitSwitchSection(SwitchSectionSyntax node)
{
foreach (var label in node.Labels)
{
var match = label as CasePatternSwitchLabelSyntax;
if (match != null)
{
var previousNodeToBind = _nodeToBind;
_nodeToBind = match;
Visit(match.Pattern);
if (match.WhenClause != null)
{
VisitNodeToBind(match.WhenClause.Condition);
}
_nodeToBind = previousNodeToBind;
}
}
}
private static Task <Document> RefactorAsync(
Document document,
SyntaxListSelection <SwitchLabelSyntax> selectedLabels,
IComparer <SwitchLabelSyntax> comparer,
CancellationToken cancellationToken = default)
{
SyntaxList <SwitchLabelSyntax> labels = selectedLabels.UnderlyingList;
SyntaxList <SwitchLabelSyntax> newLabels = labels.ReplaceRange(
selectedLabels.FirstIndex,
selectedLabels.Count,
selectedLabels.OrderBy(f => f, comparer));
var section = (SwitchSectionSyntax)labels[0].Parent;
SwitchSectionSyntax newSection = section.WithLabels(newLabels);
return(document.ReplaceNodeAsync(section, newSection, cancellationToken));
}
public static string SwitchSection(SwitchSectionSyntax node)
{
var output = "";
foreach (var label in node.Labels)
{
output += SyntaxNode(label);
}
foreach (var statement in node.Statements)
{
if (statement is BreakStatementSyntax)
{
break;
}
output += " " + SyntaxNode(statement); //TODO: fix the tabbing here with Indenter.cs
}
return(output);
}
private static SwitchSectionSyntax CreateSectionWithoutStatements(SwitchSectionSyntax section)
{
SwitchSectionSyntax newSection = section.WithStatements(List <StatementSyntax>());
if (newSection
.GetTrailingTrivia()
.All(f => f.IsWhitespaceTrivia()))
{
newSection = newSection.WithoutTrailingTrivia();
}
if (section
.SyntaxTree
.IsSingleLineSpan(TextSpan.FromBounds(section.Labels.Last().SpanStart, section.Span.End)))
{
newSection = newSection.AppendToTrailingTrivia(section.GetTrailingTrivia());
}
return(newSection);
}
internal static bool HasBraces(SwitchSectionSyntax section)
{
switch (section.Statements.Count)
{
case 1:
if (section.Statements.First() is BlockSyntax)
{
return(true);
}
break;
case 2:
if (section.Statements.First() is BlockSyntax && section.Statements.Last() is BreakStatementSyntax)
{
return(true);
}
break;
}
return(false);
}
internal static SyntaxList <StatementSyntax> GetStatementsOrDefault(SwitchSectionSyntax section)
{
foreach (SwitchLabelSyntax label in section.Labels)
{
if (!label.Kind().Is(SyntaxKind.CaseSwitchLabel, SyntaxKind.DefaultSwitchLabel))
{
return(default(SyntaxList <StatementSyntax>));
}
}
SyntaxList <StatementSyntax> statements = section.Statements;
if (statements.Count == 1 &&
(statements[0] is BlockSyntax block))
{
return(block.Statements);
}
return(statements);
}
public override void VisitSwitchSection(SwitchSectionSyntax node)
{
if (debug)
{
Console.WriteLine(node.ToFullString());
}
var nl = OurLine.NewLine(LineKind.Decl, "SwitchSection");
OurLine.AddEssentialInfo(ref nl, "labels:" + node.Labels.ToString());
// OurLine.AddEssentialInfo(ref nl, node.Labels.Select((l) => l.Value.ToString()));
OurLine.AddEssentialInfo(ref nl, "statements:" + node.Statements.ToString());
nl.Source = node.ToFullString();
nl.ParentKind = node.Parent.RawKind;
nl.RawKind = node.RawKind;
LogCommand(nl);
StartBlock("SwitchSection");
base.VisitSwitchSection(node);
EndBlock("SwitchSection");
}
public static bool CanAddBracesToSection(SwitchSectionSyntax section)
{
if (section == null)
{
throw new ArgumentNullException(nameof(section));
}
if (section.Statements.Count > 1)
{
return(true);
}
else if (section.Statements.Count == 1 && !section.Statements[0].IsKind(SyntaxKind.Block))
{
return(true);
}
else
{
return(false);
}
}
private static void AnalyzeSwitchStatement(SyntaxNodeAnalysisContext context)
{
var switchStatement = (SwitchStatementSyntax)context.Node;
SyntaxList <SwitchSectionSyntax> sections = switchStatement.Sections;
SyntaxList <SwitchSectionSyntax> .Enumerator en = sections.GetEnumerator();
if (!en.MoveNext())
{
return;
}
SwitchSectionSyntax previousSection = en.Current;
var previousBlock = previousSection.Statements.SingleOrDefault(shouldThrow: false) as BlockSyntax;
while (en.MoveNext())
{
SyntaxTriviaList leadingTrivia = en.Current.Labels[0].GetLeadingTrivia();
if (SyntaxTriviaAnalysis.IsEmptyOrSingleWhitespaceTrivia(leadingTrivia))
{
SyntaxTriviaList trailingTrivia = previousSection.GetTrailingTrivia();
if (SyntaxTriviaAnalysis.IsOptionalWhitespaceThenOptionalSingleLineCommentThenEndOfLineTrivia(trailingTrivia) &&
(context.GetBlankLineBetweenClosingBraceAndSwitchSection() != false ||
previousBlock == null))
{
DiagnosticHelpers.ReportDiagnostic(
context,
DiagnosticRules.AddBlankLineBetweenSwitchSections,
Location.Create(switchStatement.SyntaxTree, trailingTrivia.Last().Span.WithLength(0)));
}
}
previousSection = en.Current;
previousBlock = en.Current.Statements.SingleOrDefault(shouldThrow: false) as BlockSyntax;
}
}
public override void VisitSwitchSection(SwitchSectionSyntax node)
{
if (!PreVisit(node))
{
return;
}
foreach (SwitchLabelSyntax labelSyntax in node.Labels)
{
labelSyntax.Accept(this);
}
foreach (StatementSyntax statement in node.Statements)
{
statement.Accept(this);
}
base.VisitSwitchSection(node);
PostVisit(node);
}
private static void AddUsingToEndOfBlock(DocumentEditor editor, SwitchSectionSyntax switchSection, LocalDeclarationStatementSyntax statement)
{
var statements = switchSection.Statements
.Where(s => s.SpanStart > statement.SpanStart)
.Where(s => !(s == switchSection.Statements.Last() &&
s is BreakStatementSyntax))
.ToArray();
foreach (var statementSyntax in statements)
{
editor.RemoveNode(statementSyntax);
}
editor.ReplaceNode(
statement,
SyntaxFactory.UsingStatement(
declaration: statement.Declaration,
expression: null,
statement: SyntaxFactory.Block(SyntaxFactory.List(statements))
.WithAdditionalAnnotations(Formatter.Annotation)));
}
private static bool ContainsOnlyBreakStatement(SwitchSectionSyntax switchSection)
{
StatementSyntax statement = switchSection.SingleStatementOrDefault();
switch (statement?.Kind())
{
case SyntaxKind.Block:
{
return(((BlockSyntax)statement)
.SingleStatementOrDefault()?
.IsKind(SyntaxKind.BreakStatement) == true);
}
case SyntaxKind.BreakStatement:
{
return(true);
}
}
return(false);
}
public override void VisitSwitchSection(SwitchSectionSyntax node)
{
if (entryNode is AnonymousFunctionExpressionSyntax && embeddedNode is AnonymousFunctionExpressionSyntax)
{
return;
}
if (_weComeFromMethod && _weInAnonymousMethod)
{
return;
}
InsertLLOCMap(node.GetLocation());
foreach (var statement in node.Statements)
{
InsertLLOCMap(statement.GetLocation());
}
foreach (var label in node.Labels)
{
InsertLLOCMap(label.GetLocation());
}
base.VisitSwitchSection(node);
}
private static void AnalyzeFirstStatement(SyntaxNodeAnalysisContext context, SwitchSectionSyntax switchSection)
{
SyntaxList <StatementSyntax> statements = switchSection.Statements;
if (statements.Count == 0)
{
return;
}
if (switchSection.Labels.Count == 0)
{
return;
}
if (switchSection.Labels.Last().GetSpanEndLine() == statements[0].GetSpanStartLine())
{
context.ReportDiagnostic(
DiagnosticDescriptors.FormatSwitchSectionStatementOnSeparateLine,
statements[0].GetLocation());
}
}
private static bool IsEmptyOrContainsOnlyDefaultSection(SwitchStatementSyntax switchStatement)
{
SyntaxList <SwitchSectionSyntax> sections = switchStatement.Sections;
if (!sections.Any())
{
return(true);
}
else if (sections.Count == 1)
{
SwitchSectionSyntax section = sections[0];
SyntaxList <SwitchLabelSyntax> labels = section.Labels;
return(labels.Count == 1 &&
labels[0].IsKind(SyntaxKind.DefaultSwitchLabel));
}
else
{
return(false);
}
}
internal static void AnalyzeSwitchStatement(SyntaxNodeAnalysisContext context)
{
var switchStatement = (SwitchStatementSyntax)context.Node;
if (!switchStatement.ContainsDiagnostics)
{
SyntaxList <SwitchSectionSyntax> sections = switchStatement.Sections;
SwitchSectionSyntax defaultSection = FindDefaultSection(sections);
if (defaultSection != null &&
ContainsOnlyBreakStatement(defaultSection) &&
!switchStatement.DescendantNodes(sections.Span).Any(f => f.IsKind(SyntaxKind.GotoDefaultStatement)) &&
defaultSection
.DescendantTrivia(defaultSection.Span)
.All(f => f.IsWhitespaceOrEndOfLineTrivia()))
{
context.ReportDiagnostic(DiagnosticDescriptors.RemoveRedundantDefaultSwitchSection, defaultSection);
}
}
}
public static Doc Print(SwitchSectionSyntax node)
{
var docs = new List <Doc> {
Doc.Join(Doc.HardLine, node.Labels.Select(Node.Print))
};
if (node.Statements.Count == 1 && node.Statements[0] is BlockSyntax blockSyntax)
{
docs.Add(Block.Print(blockSyntax));
}
else
{
docs.Add(
Doc.Indent(
Doc.HardLine,
Doc.Join(Doc.HardLine, node.Statements.Select(Node.Print).ToArray())
)
);
}
return(Doc.Concat(docs));
}
public static void Analyze(SyntaxNodeAnalysisContext context, SwitchSectionSyntax switchSection)
{
SyntaxList <SwitchLabelSyntax> labels = switchSection.Labels;
for (int i = 0; i < labels.Count - 1; i++)
{
SwitchLabelSyntax label = labels[i];
if (label.IsKind(SyntaxKind.DefaultSwitchLabel))
{
TextSpan span = TextSpan.FromBounds(label.Span.End, labels.Last().Span.Start);
if (!switchSection.ContainsDirectives(span))
{
context.ReportDiagnostic(
DiagnosticDescriptors.DefaultLabelShouldBeLastLabelInSwitchSection,
label);
}
}
}
}
public static async Task <Document> RefactorAsync(
Document document,
SwitchSectionSyntax switchSection,
CancellationToken cancellationToken = default(CancellationToken))
{
SyntaxList <SwitchLabelSyntax> labels = switchSection.Labels;
SwitchLabelSyntax defaultLabel = labels.First(f => f.IsKind(SyntaxKind.DefaultSwitchLabel));
int index = labels.IndexOf(defaultLabel);
SwitchLabelSyntax lastLabel = labels.Last();
labels = labels.Replace(lastLabel, defaultLabel.WithTriviaFrom(lastLabel));
labels = labels.Replace(labels[index], lastLabel.WithTriviaFrom(defaultLabel));
SwitchSectionSyntax newSwitchSection = switchSection.WithLabels(labels);
return(await document.ReplaceNodeAsync(switchSection, newSwitchSection, cancellationToken).ConfigureAwait(false));
}
public static bool CanRefactor(SyntaxNodeAnalysisContext context, SwitchSectionSyntax switchSection)
{
SwitchLabelSyntax label = switchSection.Labels.LastOrDefault();
if (label != null)
{
ImmutableArray <Diagnostic> diagnostics = context.SemanticModel.GetDiagnostics(label.Span, context.CancellationToken);
for (int i = 0; i < diagnostics.Length; i++)
{
switch (diagnostics[i].Id)
{
case "CS0163":
case "CS8070":
return(true);
}
}
}
return(false);
}
private static IEnumerable <SwitchSectionSyntax> CreateSwitchSections(
SwitchSectionSyntax section,
SyntaxListSelection <SwitchLabelSyntax> selectedLabels,
int lastIndex)
{
int firstIndex = selectedLabels.FirstIndex;
if (firstIndex > 0)
{
yield return(SwitchSection(section.Labels.Take(firstIndex + 1).ToSyntaxList(), BreakStatement())
.WithFormatterAnnotation());
firstIndex++;
}
for (int i = firstIndex; i <= lastIndex; i++)
{
yield return(SwitchSection(selectedLabels.UnderlyingList[i], BreakStatement())
.WithFormatterAnnotation());
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, SwitchSectionSyntax switchSection)
{
SyntaxList <StatementSyntax> statements = switchSection.Statements;
if (statements.Any())
{
SyntaxList <SwitchLabelSyntax> labels = switchSection.Labels;
if (labels.Any())
{
StatementSyntax statement = statements.First();
if (switchSection.SyntaxTree.IsSingleLineSpan(TextSpan.FromBounds(labels.Last().Span.End, statement.SpanStart)))
{
context.ReportDiagnostic(
DiagnosticDescriptors.FormatSwitchSectionStatementOnSeparateLine,
statement);
}
}
}
}
internal static bool HasBraces(SwitchSectionSyntax section)
{
if (section.Statements.Count == 1)
{
var firstStatement = section.Statements.First();
if (firstStatement is BlockSyntax)
{
return(true);
}
}
else if (section.Statements.Count == 2)
{
var firstStatement = section.Statements.First();
var lastStatement = section.Statements.Last();
if (firstStatement is BlockSyntax && lastStatement is BreakStatementSyntax)
{
return(true);
}
}
return(false);
}
public override void VisitSwitchSection(SwitchSectionSyntax node)
{
// switch label should initialize the LastWhen clause
LastWhen = null;
foreach (var label in node.Labels.EmptyIfNull())
{
label.Accept(this);
}
// no labels per swith section? looks like the source file is broken
if (LastWhen == null)
{
throw new InvalidOperationException("Unsupported switch section format. " +
"Case expression, pattern or default label is expected.");
}
var lastWhen = LastWhen;
lastWhen.LeadingComments = GetLeadingAndNoApexComments(node);
lastWhen.Block = new ApexBlockSyntax();
foreach (var stmt in node.Statements.EmptyIfNull())
{
stmt.Accept(this);
if (LastStatement != null)
{
lastWhen.Block.Statements.Add(LastStatement);
LastStatement = null;
}
}
// remove C#'s break statement from the block keeping its trailing comments
if (lastWhen.Block.Statements.LastOrDefault() is ApexBreakStatementSyntax @break)
{
lastWhen.Block.Statements.Remove(@break);
lastWhen.Block.TrailingComments = @break.TrailingComments;
}
LastWhen = lastWhen;
}
private static BoundPatternSwitchSection BindPatternSwitchSection(BoundExpression boundSwitchExpression, SwitchSectionSyntax node, Binder originalBinder, ref DefaultSwitchLabelSyntax defaultLabel, DiagnosticBag diagnostics)
{
// Bind match section labels
var boundLabelsBuilder = ArrayBuilder<BoundPatternSwitchLabel>.GetInstance();
var sectionBinder = originalBinder.GetBinder(node); // this binder can bind pattern variables from the section.
Debug.Assert(sectionBinder != null);
foreach (var labelSyntax in node.Labels)
{
BoundPatternSwitchLabel boundLabel = BindPatternSwitchSectionLabel(sectionBinder, boundSwitchExpression, labelSyntax, ref defaultLabel, diagnostics);
boundLabelsBuilder.Add(boundLabel);
}
// Bind switch section statements
var boundStatementsBuilder = ArrayBuilder<BoundStatement>.GetInstance();
foreach (var statement in node.Statements)
{
boundStatementsBuilder.Add(sectionBinder.BindStatement(statement, diagnostics));
}
return new BoundPatternSwitchSection(node, sectionBinder.GetDeclaredLocalsForScope(node), boundLabelsBuilder.ToImmutableAndFree(), boundStatementsBuilder.ToImmutableAndFree());
}
private static SyntaxList <StatementSyntax> GetSectionStatements(SwitchSectionSyntax switchSection)
{
SyntaxList <StatementSyntax> statements = switchSection.Statements;
if (statements.Count == 1 &&
statements[0].IsKind(SyntaxKind.Block))
{
statements = ((BlockSyntax)statements[0]).Statements;
}
if (statements.Any())
{
StatementSyntax last = statements.Last();
if (last.IsKind(SyntaxKind.BreakStatement))
{
return(statements.Remove(last));
}
}
return(statements);
}
public virtual void VisitSwitchSection(SwitchSectionSyntax node)
{
DefaultVisit(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitSwitchSection(SwitchSectionSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitSwitchSection(node);
}
private BoundSwitchSection BindSwitchSection(SwitchSectionSyntax node, Binder originalBinder, DiagnosticBag diagnostics)
{
var sectionBinder = originalBinder.GetBinder(node);
// Bind switch section labels
var boundLabelsBuilder = ArrayBuilder<BoundSwitchLabel>.GetInstance();
foreach (var labelSyntax in node.Labels)
{
LabelSymbol label = LabelsByNode[labelSyntax];
BoundSwitchLabel boundLabel = BindSwitchSectionLabel(labelSyntax, sectionBinder, label, diagnostics);
boundLabelsBuilder.Add(boundLabel);
}
// Bind switch section statements
var boundStatementsBuilder = ArrayBuilder<BoundStatement>.GetInstance();
foreach (var statement in node.Statements)
{
boundStatementsBuilder.Add(sectionBinder.BindStatement(statement, diagnostics));
}
return new BoundSwitchSection(node, boundLabelsBuilder.ToImmutableAndFree(), boundStatementsBuilder.ToImmutableAndFree());
}
/// <summary>
/// Bind the pattern switch section, producing subsumption diagnostics.
/// </summary>
/// <param name="boundSwitchExpression"/>
/// <param name="node"/>
/// <param name="originalBinder"/>
/// <param name="defaultLabel">If a default label is found in this section, assigned that label</param>
/// <param name="someValueMatched">If a constant label is found that matches the constant input, assigned that label</param>
/// <param name="subsumption">A helper class that uses a decision tree to produce subsumption diagnostics.</param>
/// <param name="diagnostics"></param>
/// <returns></returns>
private BoundPatternSwitchSection BindPatternSwitchSection(
BoundExpression boundSwitchExpression,
SwitchSectionSyntax node,
Binder originalBinder,
ref BoundPatternSwitchLabel defaultLabel,
ref bool someValueMatched,
SubsumptionDiagnosticBuilder subsumption,
DiagnosticBag diagnostics)
{
// Bind match section labels
var boundLabelsBuilder = ArrayBuilder<BoundPatternSwitchLabel>.GetInstance();
var sectionBinder = originalBinder.GetBinder(node); // this binder can bind pattern variables from the section.
Debug.Assert(sectionBinder != null);
var labelsByNode = LabelsByNode;
foreach (var labelSyntax in node.Labels)
{
LabelSymbol label = labelsByNode[labelSyntax];
BoundPatternSwitchLabel boundLabel = BindPatternSwitchSectionLabel(sectionBinder, boundSwitchExpression, labelSyntax, label, ref defaultLabel, diagnostics);
bool valueMatched; // true if we find an unconditional constant label that matches the input constant's value
bool isReachable = subsumption.AddLabel(boundLabel, diagnostics, out valueMatched);
boundLabel = boundLabel.Update(boundLabel.Label, boundLabel.Pattern, boundLabel.Guard, isReachable && !someValueMatched);
someValueMatched |= valueMatched;
boundLabelsBuilder.Add(boundLabel);
}
// Bind switch section statements
var boundStatementsBuilder = ArrayBuilder<BoundStatement>.GetInstance();
foreach (var statement in node.Statements)
{
boundStatementsBuilder.Add(sectionBinder.BindStatement(statement, diagnostics));
}
return new BoundPatternSwitchSection(node, sectionBinder.GetDeclaredLocalsForScope(node), boundLabelsBuilder.ToImmutableAndFree(), boundStatementsBuilder.ToImmutableAndFree());
}
public SwitchSectionTranslation(SwitchSectionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Labels = syntax.Labels.Get<SwitchLabelSyntax, SwitchLabelTranslation>(this);
Statements = syntax.Statements.Get<StatementSyntax, StatementTranslation>(this);
}
private BoundSwitchSection BindSwitchSection(SwitchSectionSyntax node, DiagnosticBag diagnostics)
{
// Bind switch section labels
var boundLabelsBuilder = ArrayBuilder<BoundSwitchLabel>.GetInstance();
foreach (var labelSyntax in node.Labels)
{
BoundSwitchLabel boundLabel = BindSwitchSectionLabel(labelSyntax, diagnostics);
boundLabelsBuilder.Add(boundLabel);
}
// Bind switch section statements
var boundStatementsBuilder = ArrayBuilder<BoundStatement>.GetInstance();
foreach (var statement in node.Statements)
{
boundStatementsBuilder.Add(BindStatement(statement, diagnostics));
}
return new BoundSwitchSection(node, boundLabelsBuilder.ToImmutableAndFree(), boundStatementsBuilder.ToImmutableAndFree());
}
private static void ReportSection(SyntaxNodeAnalysisContext c, SwitchSectionSyntax switchSection, SwitchSectionSyntax precedingSection)
{
ReportSyntaxNode(c, switchSection, precedingSection, "case");
}
public override void VisitSwitchSection(SwitchSectionSyntax node)
{
var patternBinder = new ExpressionVariableBinder(node, _enclosing);
AddToMap(node, patternBinder);
foreach (var label in node.Labels)
{
switch (label.Kind())
{
case SyntaxKind.CasePatternSwitchLabel:
{
var switchLabel = (CasePatternSwitchLabelSyntax)label;
Visit(switchLabel.Pattern, patternBinder);
if (switchLabel.WhenClause != null)
{
Visit(switchLabel.WhenClause.Condition, patternBinder);
}
break;
}
case SyntaxKind.CaseSwitchLabel:
{
var switchLabel = (CaseSwitchLabelSyntax)label;
Visit(switchLabel.Value, patternBinder);
break;
}
}
}
foreach (StatementSyntax statement in node.Statements)
{
Visit(statement, patternBinder);
}
}
private BoundSwitchSection BindSwitchSection(SwitchSectionSyntax syntax, Symbol parent)
{
return new BoundSwitchSection(
syntax.Labels.Select(x => Bind(x, BindSwitchLabel)).ToImmutableArray(),
syntax.Statements.Select(x => Bind(x, y => BindStatement(y, parent))).ToImmutableArray());
}
private bool Equal(SwitchSectionSyntax left, SwitchSectionSyntax right)
{
return SyntaxFactory.AreEquivalent(left.Labels, right.Labels, null)
&& SyntaxFactory.AreEquivalent(left.Statements, right.Statements, ignoreChildNode: IgnoreLabeledChild);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitSwitchSection(SwitchSectionSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitSwitchSection(node);
}
/// <remarks>
/// Used to determine whether it would be appropriate to use the binder for the switch section (if any).
/// Not used to determine whether the position is syntactically within the statement.
/// </remarks>
internal static bool IsInSwitchSectionScope(int position, SwitchSectionSyntax section)
{
Debug.Assert(section != null);
return section.Span.Contains(position);
}
public override void VisitSwitchSection(SwitchSectionSyntax node)
{
var patternBinder = new PatternVariableBinder(node, _enclosing);
AddToMap(node, patternBinder);
foreach (var label in node.Labels)
{
var match = label as CasePatternSwitchLabelSyntax;
if (match != null)
{
Visit(match.Pattern, patternBinder);
if (match.WhenClause != null)
{
Visit(match.WhenClause.Condition, patternBinder);
}
}
}
foreach (StatementSyntax statement in node.Statements)
{
Visit(statement, patternBinder);
}
}
public override void VisitSwitchSection(SwitchSectionSyntax node)
{
}
public override void VisitSwitchSection(SwitchSectionSyntax node)
{
foreach (StatementSyntax statement in node.Statements)
{
Visit(statement, _enclosing);
}
}
public override SyntaxNode VisitSwitchSection(SwitchSectionSyntax node) //TODO: Should fix string switch here
{
return base.VisitSwitchSection(node);
}
private static SwitchSectionSyntax AddBraces(SwitchSectionSyntax section)
{
StatementSyntax blockStatement = SyntaxFactory.Block(section.Statements).WithoutTrailingTrivia();
return section.Update(section.Labels, SyntaxFactory.SingletonList(blockStatement));
}
public BoundSwitchSection(SwitchSectionSyntax syntax, ImmutableArray<BoundSwitchLabel> labels, ImmutableArray<BoundStatement> statements)
: base(BoundNodeKind.SwitchSection, syntax)
{
Labels = labels;
Statements = statements;
}
public void VisitSwitchSection(SwitchSectionSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
WriteLeadingTrivia(node);
bool hadOne = false;
foreach (var label in node.Labels)
{
if (hadOne)
_writer.WriteLine();
else
hadOne = true;
label.Accept(this);
}
_writer.PushBraceFormatting(_writer.Configuration.BracesLayout.BlockUnderCaseLabel, false);
foreach (var statement in node.Statements)
{
VisitBlockStatement(statement);
}
_writer.PopBraceFormatting();
WriteTrailingTrivia(node);
}
