private static void HandleEmptyStatement(SyntaxNodeAnalysisContext context)
{
EmptyStatementSyntax syntax = (EmptyStatementSyntax)context.Node;
LabeledStatementSyntax labeledStatementSyntax = syntax.Parent as LabeledStatementSyntax;
if (labeledStatementSyntax != null)
{
BlockSyntax blockSyntax = labeledStatementSyntax.Parent as BlockSyntax;
if (blockSyntax != null)
{
for (int i = blockSyntax.Statements.Count - 1; i >= 0; i--)
{
StatementSyntax statement = blockSyntax.Statements[i];
// allow an empty statement to be used for a label, but only if no non-empty statements exist
// before the end of the block
if (blockSyntax.Statements[i] == labeledStatementSyntax)
{
return;
}
if (!statement.IsKind(SyntaxKind.EmptyStatement))
{
break;
}
}
}
}
// Code must not contain empty statements
context.ReportDiagnostic(Diagnostic.Create(Descriptor, syntax.GetLocation()));
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
base.VisitLabeledStatement(node);
StatementsAnalyzer statementsAnalyzer = this;
statementsAnalyzer.counter = checked (statementsAnalyzer.counter + 1);
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
var location = node.StartLocation();
this.labelLocations[node.Identifier.ValueText] = location;
this.JoinState(location, this.lexicalState);
base.VisitLabeledStatement(node);
}
public override SyntaxNode VisitLabeledStatement(LabeledStatementSyntax node)
{
var statement = (GotoStatementSyntax)node.Statement;
var line = GetLineNumber(node) - 1;
var updated = Block(ThrowIfCancelled.WithTrailingTrivia(GetLineDirective(line)), statement);
return(base.VisitLabeledStatement(node.ReplaceNode(node.Statement, updated)));
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
base.VisitLabeledStatement(node);
if (!yieldOnly)
{
isSpecial = true;
}
}
private Block BuildLabeledStatement(LabeledStatementSyntax labeledStatement, Block currentBlock)
{
var statementBlock = BuildStatement(labeledStatement.Statement, currentBlock);
var jumpBlock = CreateJumpBlock(labeledStatement, statementBlock);
LabeledStatements[labeledStatement.Identifier.ValueText] = jumpBlock;
return(CreateBlock(jumpBlock));
}
// only for single statement or expression
public override SyntaxNode VisitLabeledStatement(LabeledStatementSyntax node)
{
if (node != this.ContainerOfStatementsOrFieldToReplace)
{
return(base.VisitLabeledStatement(node));
}
return(node.WithStatement(ReplaceStatementIfNeeded(node.Statement)));
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
if (entryPoint.IsMethodLevel() && node.IsParent <AnonymousFunctionExpressionSyntax>())
{
return;
}
noscounter++;
base.VisitLabeledStatement(node);
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
var label = node.Identifier.ToString();
var labelState = NewLabeledState(label);
GotoState(labelState);
CurrentState = labelState;
AcceptStatement(node.Statement);
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
var labelSymbol = _model.GetDeclaredSymbol(node);
var remainderBlock = _labels.GetOrCreate(labelSymbol, () => new BasicBlock(null));
remainderBlock.Terminator = _currentBlock.Terminator;
_currentBlock.Terminator = new JumpTerminator(remainderBlock);
_nextNodes.Push(node.Statement);
_currentBlock = remainderBlock;
}
private void BuildLabeledStatement(LabeledStatementSyntax labeledStatement)
{
BuildStatement(labeledStatement.Statement);
var jumpBlock = CreateJumpBlock(labeledStatement, currentBlock);
currentBlock = jumpBlock;
LabeledStatements[labeledStatement.Identifier.ValueText] = jumpBlock;
currentBlock = CreateBlock(currentBlock);
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
if (!PreVisit(node))
{
return;
}
node.Statement?.Accept(this);
base.VisitLabeledStatement(node);
PostVisit(node);
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
if (entryNode is AnonymousFunctionExpressionSyntax && embeddedNode is AnonymousFunctionExpressionSyntax)
{
return;
}
if (_weComeFromMethod && _weInAnonymousMethod)
{
return;
}
InsertLLOCMap(node.GetLocation());
InsertLLOCMap(node.ColonToken.GetLocation());
base.VisitLabeledStatement(node);
}
private Doc PrintLabeledStatementSyntax(LabeledStatementSyntax node)
{
var parts = new Parts(
this.PrintExtraNewLines(node),
this.PrintAttributeLists(node, node.AttributeLists),
this.PrintSyntaxToken(node.Identifier),
this.PrintSyntaxToken(node.ColonToken)
);
if (node.Statement is BlockSyntax blockSyntax)
{
parts.Push(this.PrintBlockSyntax(blockSyntax));
}
else
{
parts.Push(HardLine, this.Print(node.Statement));
}
return(Concat(parts));
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
MaybeCreateNewState();
var nextState = GetNextState(node);
var labelState = currentState;
labelStates[node.Identifier.ToString()] = labelState;
labelState.NextState = nextState;
node.Statement.Accept(this);
if (currentState != nextState)
{
Close(currentState);
}
currentState = nextState;
}
public static Doc Print(LabeledStatementSyntax node)
{
var docs = new List <Doc>
{
ExtraNewLines.Print(node),
AttributeLists.Print(node, node.AttributeLists),
Token.Print(node.Identifier),
Token.Print(node.ColonToken)
};
if (node.Statement is BlockSyntax blockSyntax)
{
docs.Add(Block.Print(blockSyntax));
}
else
{
docs.Add(Doc.HardLine, Node.Print(node.Statement));
}
return(Doc.Concat(docs));
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
var identifier = node.Identifier.Text;
var basicBlocks = this.labels.Peek();
LLVMBasicBlockRef gotoBB;
if (!basicBlocks.TryGetValue(identifier, out gotoBB))
{
gotoBB = LLVM.AppendBasicBlock(this.function, identifier);
basicBlocks.Add(identifier, gotoBB);
}
LLVM.BuildBr(this.builder, gotoBB);
LLVM.PositionBuilderAtEnd(this.builder, gotoBB);
this.Visit(node.Statement);
LLVMBasicBlockRef postGotoBB = LLVM.AppendBasicBlock(this.function, string.Concat("Post", identifier));
LLVM.BuildBr(this.builder, postGotoBB);
LLVM.PositionBuilderAtEnd(this.builder, postGotoBB);
}
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
if (!Settings.IsCodeFixEnabled(CodeFixIdentifiers.RemoveUnusedLabel))
{
return;
}
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
LabeledStatementSyntax labeledStatement = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <LabeledStatementSyntax>();
Debug.Assert(labeledStatement != null, $"{nameof(labeledStatement)} is null");
if (labeledStatement == null)
{
return;
}
foreach (Diagnostic diagnostic in context.Diagnostics)
{
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.LabelHasNotBeenReferenced:
{
CodeAction codeAction = CodeAction.Create(
"Remove unused label",
cancellationToken => context.Document.RemoveStatementAsync(labeledStatement, context.CancellationToken),
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
}
public override IStatement VisitLabeledStatement(LabeledStatementSyntax node)
{
ILabeledStatement l;
var id = node.Identifier;
if (!this.labelTable.TryGetValue(id.Value, out l))
{
l = new LabeledStatement()
{
Label = this.host.NameTable.GetNameFor(id.ValueText),
Locations = Helper.SourceLocation(this.tree, node),
};
this.labelTable.Add(id.Value, l);
}
var s_prime = this.Visit(node.Statement);
return(new BlockStatement()
{
Statements = new List <IStatement>()
{
l, s_prime,
},
});
}
public LabeledStatementTranslation(LabeledStatementSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Statement = syntax.Statement.Get<StatementTranslation>(this);
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
Visit(node.Statement, _enclosing);
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
MaybeCreateNewState();
var nextState = GetNextState(node);
var labelState = currentState;
labelStates[node.Identifier.ToString()] = labelState;
labelState.NextState = nextState;
node.Statement.Accept(this);
if (currentState != nextState)
{
Close(currentState);
}
currentState = nextState;
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitLabeledStatement(LabeledStatementSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitLabeledStatement(node);
}
private BoundLabeledStatement BindLabeled(LabeledStatementSyntax node, DiagnosticBag diagnostics)
{
// TODO: verify that goto label lookup was valid (e.g. error checking of symbol resolution for labels)
bool hasError = false;
var result = LookupResult.GetInstance();
HashSet<DiagnosticInfo> useSiteDiagnostics = null;
this.LookupSymbolsWithFallback(result, node.Identifier.ValueText, arity: 0, useSiteDiagnostics: ref useSiteDiagnostics, options: LookupOptions.LabelsOnly);
// result.Symbols can be empty in some malformed code, e.g. when a labeled statement is used an embedded statement in an if or foreach statement
// In this case we create new label symbol on the fly, and an error is reported by parser
var symbol = result.Symbols.Count != 0 ?
(LabelSymbol)result.Symbols.First() :
new SourceLabelSymbol((MethodSymbol)ContainingMemberOrLambda, node.Identifier);
if (!symbol.IdentifierNodeOrToken.IsToken || symbol.IdentifierNodeOrToken.AsToken() != node.Identifier)
{
Error(diagnostics, ErrorCode.ERR_DuplicateLabel, node.Identifier, node.Identifier.ValueText);
hasError = true;
}
// check to see if this label (illegally) hides a label from an enclosing scope
result.Clear();
this.Next.LookupSymbolsWithFallback(result, node.Identifier.ValueText, arity: 0, useSiteDiagnostics: ref useSiteDiagnostics, options: LookupOptions.LabelsOnly);
if (result.IsMultiViable)
{
// The label '{0}' shadows another label by the same name in a contained scope
Error(diagnostics, ErrorCode.ERR_LabelShadow, node.Identifier, node.Identifier.ValueText);
hasError = true;
}
diagnostics.Add(node, useSiteDiagnostics);
result.Free();
var body = BindStatement(node.Statement, diagnostics);
return new BoundLabeledStatement(node, symbol, body, hasError);
}
protected internal override object VisitLabeledStatement(LabeledStatementSyntax node, Binder enclosing)
{
Visit(node.Statement, enclosing);
return(null);
}
/// <summary>
/// Given a labeled statement syntax, get the corresponding label symbol.
/// </summary>
/// <param name="declarationSyntax">The syntax node of the labeled statement.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The label symbol for that label.</returns>
public override ILabelSymbol GetDeclaredSymbol(LabeledStatementSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
{
using (Logger.LogBlock(FunctionId.CSharp_SemanticModel_GetDeclaredSymbol, message: this.SyntaxTree.FilePath, cancellationToken: cancellationToken))
{
CheckSyntaxNode(declarationSyntax);
var memberModel = this.GetMemberModel(declarationSyntax);
return memberModel == null ? null : memberModel.GetDeclaredSymbol(declarationSyntax, cancellationToken);
}
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
base.VisitLabeledStatement(node);
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitLabeledStatement(LabeledStatementSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitLabeledStatement(node);
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
Visit(node.Statement, _enclosing);
}
public void VisitLabeledStatement(LabeledStatementSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
WriteLeadingTrivia(node);
_writer.PushIndent(-_writer.Configuration.Indentation);
_writer.WriteIndent();
_writer.WriteIdentifier(node.Identifier);
_writer.WriteSyntax(Syntax.Colon);
_writer.WriteLine();
_writer.PopIndent();
WriteTrailingTrivia(node);
node.Statement.Accept(this);
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
base.VisitLabeledStatement(node);
if (!yieldOnly)
isSpecial = true;
}
private BoundLabeledStatement BindLabeled(LabeledStatementSyntax node, DiagnosticBag diagnostics)
{
// TODO: verify that goto label lookup was valid (e.g. error checking of symbol resolution for labels)
bool hasError = false;
var result = LookupResult.GetInstance();
HashSet<DiagnosticInfo> useSiteDiagnostics = null;
this.LookupSymbolsWithFallback(result, node.Identifier.ValueText, arity: 0, useSiteDiagnostics: ref useSiteDiagnostics, options: LookupOptions.LabelsOnly);
var symbol = (LabelSymbol)result.Symbols.First();
if (!symbol.IdentifierNodeOrToken.IsToken || symbol.IdentifierNodeOrToken.AsToken() != node.Identifier)
{
Error(diagnostics, ErrorCode.ERR_DuplicateLabel, node.Identifier, node.Identifier.ValueText);
hasError = true;
}
// check to see if this label (illegally) hides a label from an enclosing scope
result.Clear();
this.Next.LookupSymbolsWithFallback(result, node.Identifier.ValueText, arity: 0, useSiteDiagnostics: ref useSiteDiagnostics, options: LookupOptions.LabelsOnly);
if (result.IsMultiViable)
{
// The label '{0}' shadows another label by the same name in a contained scope
Error(diagnostics, ErrorCode.ERR_LabelShadow, node.Identifier, node.Identifier.ValueText);
hasError = true;
}
diagnostics.Add(node, useSiteDiagnostics);
result.Free();
var body = BindStatement(node.Statement, diagnostics);
return new BoundLabeledStatement(node, symbol, body, hasError);
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
base.VisitLabeledStatement(node);
_counter++;
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
throw new NotSupportedException("Labeled statements is not supported");
}
public override ILabelSymbol GetDeclaredSymbol(LabeledStatementSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
{
CheckSyntaxNode(declarationSyntax);
var binder = this.GetEnclosingBinder(GetAdjustedNodePosition(declarationSyntax));
while (binder != null && !binder.IsLabelsScopeBinder)
{
binder = binder.Next;
}
if (binder != null)
{
foreach (var label in binder.Labels)
{
if (label.IdentifierNodeOrToken.IsToken &&
label.IdentifierNodeOrToken.AsToken() == declarationSyntax.Identifier)
{
return label;
}
}
}
return null;
}
public static void Go(OutputWriter writer, LabeledStatementSyntax method)
{
writer.WriteLine(method.Identifier + ":");
Core.Write(writer, method.Statement);
}
public override void VisitLabeledStatement(LabeledStatementSyntax node) => AddRelevantExpressions(node.Statement, _expressions, _includeDeclarations);
/// <summary> /// Given a labeled statement syntax, get the corresponding label symbol. /// </summary> /// <param name="declarationSyntax">The syntax node of the labeled statement.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <returns>The label symbol for that label.</returns> public abstract ILabelSymbol GetDeclaredSymbol(LabeledStatementSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken));
/// <summary>
///
/// </summary>
/// <param name="node"></param>
/// <remarks>
/// Statements will cause an AST walker to be created, thus we don't need to go further deeper in the
/// tree by visiting the node.
/// </remarks>
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
this.VisitStatement(node);
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
CreateConnectedEndNode(node);
builder.labels[node.Identifier.ValueText] = curNode;
}
private LabelStatement TraverseLabelStatements(LabeledStatementSyntax lss)
{
LabelStatement retLabelStatement = new LabelStatement();
if (lss.HasLeadingTrivia)
{
SetOuterComments(retLabelStatement, lss.GetLeadingTrivia().ToFullString());
}
if (lss.HasTrailingTrivia)
{
SetInnerComments(retLabelStatement, lss.GetTrailingTrivia().ToFullString());
}
retLabelStatement.Name = lss.Identifier.ValueText;
return retLabelStatement;
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
this.Found |= node.Identifier.ValueText == this.name;
base.VisitLabeledStatement(node);
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
VisitStatementIfNotNull(node.Statement);
}
public ILabelSymbol?ToSymbol(LabeledStatementSyntax node) => Model.GetDeclaredSymbol(node, CancellationToken);
public override IEnumerable <IModel> VisitLabeledStatement(LabeledStatementSyntax node)
{
yield return(Visit(node.Statement).Single());
}
/// <summary>
/// Given a labeled statement syntax, get the corresponding label symbol.
/// </summary>
/// <param name="declarationSyntax">The syntax node of the labeled statement.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>The label symbol for that label.</returns>
public override ILabelSymbol GetDeclaredSymbol(LabeledStatementSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
{
CheckSyntaxNode(declarationSyntax);
var memberModel = this.GetMemberModel(declarationSyntax);
return memberModel == null ? null : memberModel.GetDeclaredSymbol(declarationSyntax, cancellationToken);
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
LogicalLineCount++;
base.VisitLabeledStatement(node);
}
public LabeledStatementTranslation(LabeledStatementSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Statement = syntax.Statement.Get <StatementTranslation>(this);
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
AddRelevantExpressions(node.Statement, _expressions, _includeDeclarations);
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
this.Found |= node.Identifier.ValueText == this.name;
base.VisitLabeledStatement(node);
}
public override void VisitLabeledStatement(LabeledStatementSyntax node)
{
this.Logic.Add(this.nodeFactory.CreateLabel(node));
}
