public static bool ResolveReturnInBody(EmbeddedStatement body)
{
if (body.GetChildsByType(typeof(ReturnStatement)).Length != 0)
{
return(true);
}
MethodDeclaration method = (MethodDeclaration)body.GetParentByType(typeof(MethodDeclaration));
SyntaxTreeNode[] ifConstructions = body.GetChildsByType(typeof(IfStatement), false, false);
if (body.Childs.Count == 0 || ifConstructions.Length == 0)
{
ReportError(new NotAllCodePathsReturnsValues(method.SourceContext));
return(false);
}
foreach (IfStatement ifConstruction in ifConstructions)
{
if (ifConstruction.ElseBody == null &&
!(ResolveReturnInBody((EmbeddedStatement)ifConstruction.Body) &&
ResolveReturnInBody((EmbeddedStatement)ifConstruction.ElseBody)))
{
return(false);
}
}
return(true);
}
private static BlockSyntax GetBlockThatCanBeEmbeddedStatement(SyntaxNode node)
{
StatementSyntax childStatement = EmbeddedStatement.GetBlockOrEmbeddedStatement(node);
if (childStatement?.IsKind(SyntaxKind.Block) == true)
{
var block = (BlockSyntax)childStatement;
SyntaxList <StatementSyntax> statements = block.Statements;
if (statements.Count == 1)
{
StatementSyntax statement = statements[0];
if (!statement.IsKind(SyntaxKind.LocalDeclarationStatement, SyntaxKind.LabeledStatement) &&
statement.IsSingleLine() &&
EmbeddedStatement.FormattingSupportsEmbeddedStatement(node))
{
return(block);
}
}
}
return(null);
}
public static void ResolveEmbeddedStatement(EmbeddedStatement body, Table.Table table)
{
Table.Table bodyTable = Table.Table.CreateTable(table);
foreach (SyntaxTreeNode statement in body.Childs)
{
ResolveStatement((Statement)statement, bodyTable);
}
}
private static void AnalyzeEmbeddedStatement(SyntaxNodeAnalysisContext context, SyntaxToken token, StatementSyntax statement)
{
if (statement != null &&
EmbeddedStatement.IsEmbeddedStatement(statement))
{
Analyze(context, token, statement);
}
}
public static async Task <Document> RefactorAsync(
Document document,
ReturnStatementSyntax returnStatement,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
SyntaxToken returnKeyword = returnStatement.ReturnKeyword;
ExpressionSyntax expression = returnStatement.Expression;
switch (GetReplacementKind(returnStatement, null, semanticModel, cancellationToken))
{
case SyntaxKind.YieldReturnStatement:
{
YieldStatementSyntax yieldReturnStatement = YieldStatement(
SyntaxKind.YieldReturnStatement,
Token(returnKeyword.LeadingTrivia, SyntaxKind.YieldKeyword, TriviaList(Space)),
returnKeyword.WithoutLeadingTrivia(),
expression,
returnStatement.SemicolonToken);
return(await document.ReplaceNodeAsync(returnStatement, yieldReturnStatement, cancellationToken).ConfigureAwait(false));
}
case SyntaxKind.ForEachStatement:
{
string identifier = Identifier.EnsureUniqueLocalName("item", returnStatement.SpanStart, semanticModel, cancellationToken);
YieldStatementSyntax yieldReturnStatement = YieldStatement(
SyntaxKind.YieldReturnStatement,
Token(default(SyntaxTriviaList), SyntaxKind.YieldKeyword, TriviaList(Space)),
returnKeyword.WithoutLeadingTrivia(),
IdentifierName(identifier),
returnStatement.SemicolonToken.WithoutTrailingTrivia());
StatementSyntax newNode = ForEachStatement(
VarType(),
identifier,
expression,
Block(yieldReturnStatement));
if (EmbeddedStatement.IsEmbeddedStatement(returnStatement))
{
newNode = Block(newNode);
}
newNode = newNode.WithTriviaFrom(returnStatement);
return(await document.ReplaceNodeAsync(returnStatement, newNode, cancellationToken).ConfigureAwait(false));
}
default:
{
Debug.Assert(false, "");
return(document);
}
}
}
public static void ResolveIdentifierExpressions(SyntaxTreeNode inNode, Table.Table table)
{
EmbeddedStatement body = (EmbeddedStatement)inNode.GetParentByType(typeof(EmbeddedStatement));
foreach (IdentifierExpression identifier in inNode.GetChildsByType(typeof(IdentifierExpression), true))
{
ResolveIdentifierExpression(identifier, table, body);
}
}
public void InitializeInBlock(IdentifierExpression identifierExpression, EmbeddedStatement block)
{
TableIdentifier identifier = FetchIdentifier(identifierExpression.Name);
if (identifier != null)
{
identifier.InitializedBlocks.Add(block);
}
}
public static void Analyze(SyntaxNodeAnalysisContext context, SyntaxNode emptyStatement)
{
SyntaxNode parent = emptyStatement.Parent;
if (parent != null &&
!EmbeddedStatement.CanContainEmbeddedStatement(parent))
{
context.ReportDiagnostic(DiagnosticDescriptors.RemoveEmptyStatement, emptyStatement);
}
}
public bool IsInitializedInBlock(IdentifierExpression identifierExpression, EmbeddedStatement block)
{
for (SyntaxTreeNode thisBlock = block; thisBlock != null; thisBlock = thisBlock.GetParentByType(typeof(EmbeddedStatement)))
{
if (this.FetchIdentifier(identifierExpression.Name).InitializedBlocks.Contains((EmbeddedStatement)thisBlock))
{
return(true);
}
}
return(false);
}
private static void Analyze(SyntaxNodeAnalysisContext context, SyntaxNode node)
{
StatementSyntax statement = EmbeddedStatement.GetEmbeddedStatement(node);
if (statement != null)
{
context.ReportDiagnostic(
DiagnosticDescriptors.AvoidEmbeddedStatementInIfElse,
statement,
node.GetTitle());
}
}
private void AnalyzeStatement(SyntaxNodeAnalysisContext context)
{
StatementSyntax statement = EmbeddedStatement.GetEmbeddedStatement(context.Node);
if (statement != null)
{
context.ReportDiagnostic(
DiagnosticDescriptors.AvoidEmbeddedStatement,
statement,
GetName(context.Node));
}
}
private static bool CanRefactor(RefactoringContext context, BlockSyntax block)
{
if (context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(block) &&
EmbeddedStatement.IsEmbeddableBlock(block))
{
StatementSyntax statement = EmbeddedStatement.GetEmbeddedStatement(block.Statements[0]);
return(statement == null ||
!statement.FullSpan.Contains(context.Span));
}
return(false);
}
private static void EmitEmbeddedStatement(EmbeddedStatement body, ILGenerator methodIL)
{
foreach (Statement statement in body.Childs)
{
EmitStatement(statement, methodIL);
}
if (body.Parent is MethodDeclaration)
{
if (((MethodDeclaration)body.Parent).ReturnType.GetEquivalence() == typeof(void))
{
methodIL.Emit(OpCodes.Ret);
}
}
}
private static StatementSyntax GetEmbeddedStatementThatShouldBeInsideBlock(SyntaxNode node)
{
StatementSyntax statement = EmbeddedStatement.GetBlockOrEmbeddedStatement(node);
if (statement?.IsKind(SyntaxKind.Block) == false)
{
if (!statement.IsSingleLine() || !EmbeddedStatement.FormattingSupportsEmbeddedStatement(node))
{
return(statement);
}
}
return(null);
}
private static async Task <Document> RefactorAsync(
Document document,
ExpressionSyntax expression,
StatementSyntax statement,
CancellationToken cancellationToken)
{
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
if (EmbeddedStatement.IsEmbeddedStatement(statement))
{
return(await document.ReplaceNodeAsync(statement, Block(statement, CreateNullCheck(expression)), cancellationToken).ConfigureAwait(false));
}
else
{
StatementContainer container;
if (StatementContainer.TryCreate(statement, out container))
{
SyntaxList <StatementSyntax> statements = container.Statements;
int statementIndex = statements.IndexOf(statement);
ISymbol symbol = (statement.IsKind(SyntaxKind.LocalDeclarationStatement))
? semanticModel.GetDeclaredSymbol(((LocalDeclarationStatementSyntax)statement).Declaration.Variables.First(), cancellationToken)
: semanticModel.GetSymbol(expression, cancellationToken);
int lastStatementIndex = IncludeAllReferencesOfSymbol(symbol, expression.Kind(), statements, statementIndex + 1, semanticModel, cancellationToken);
if (lastStatementIndex != -1)
{
if (lastStatementIndex < statements.Count - 1)
{
lastStatementIndex = IncludeAllReferencesOfVariablesDeclared(statements, statementIndex + 1, lastStatementIndex, semanticModel, cancellationToken);
}
return(await RefactorAsync(
document,
expression,
statements,
container,
statementIndex,
lastStatementIndex,
cancellationToken).ConfigureAwait(false));
}
}
}
return(await document.InsertNodeAfterAsync(statement, CreateNullCheck(expression), cancellationToken).ConfigureAwait(false));
}
private static bool NullCheckExists(ExpressionSyntax expression, StatementSyntax statement)
{
if (!EmbeddedStatement.IsEmbeddedStatement(statement))
{
StatementContainer container;
if (StatementContainer.TryCreate(statement, out container))
{
SyntaxList <StatementSyntax> statements = container.Statements;
int index = statements.IndexOf(statement);
if (index < statements.Count - 1)
{
StatementSyntax nextStatement = statements[index + 1];
if (nextStatement.IsKind(SyntaxKind.IfStatement))
{
var ifStatement = (IfStatementSyntax)nextStatement;
ExpressionSyntax condition = ifStatement.Condition;
if (condition?.IsKind(SyntaxKind.NotEqualsExpression) == true)
{
var notEqualsExpression = (BinaryExpressionSyntax)condition;
ExpressionSyntax left = notEqualsExpression.Left;
if (left?.IsEquivalentTo(expression, topLevel: false) == true)
{
ExpressionSyntax right = notEqualsExpression.Right;
if (right?.IsKind(SyntaxKind.NullLiteralExpression) == true)
{
return(true);
}
}
}
}
}
}
}
return(false);
}
private static BlockSyntax GetBlockThatCanBeEmbeddedStatement(SyntaxNode node)
{
StatementSyntax childStatement = EmbeddedStatement.GetBlockOrEmbeddedStatement(node);
if (childStatement?.IsKind(SyntaxKind.Block) == true)
{
var block = (BlockSyntax)childStatement;
StatementSyntax statement = block.SingleStatementOrDefault();
if (statement?.IsKind(SyntaxKind.LocalDeclarationStatement, SyntaxKind.LabeledStatement) == false &&
statement.IsSingleLine() &&
EmbeddedStatement.FormattingSupportsEmbeddedStatement(node))
{
return(block);
}
}
return(null);
}
public static void ResolveAdressor(Expression adressor, EmbeddedStatement body, Table.Table table)
{
if (adressor is IdentifierExpression)
{
ResolveIdentifierExpression((IdentifierExpression)adressor, table, body, false);
TableIdentifier tableIdentifier = table.FetchIdentifier(((IdentifierExpression)adressor).Name);
if (tableIdentifier != null && tableIdentifier.IsGlobal)
{
tableIdentifier.InitializedGlobally = true;
}
else
{
table.InitializeInBlock((IdentifierExpression)adressor, body);
}
}
else
{
ResolveArrayElement((ArrayElementExpression)adressor, table, true);
}
}
private static bool CanRefactorIfElse(BlockSyntax selectedBlock, IfStatementSyntax topmostIf)
{
bool success = false;
foreach (BlockSyntax block in GetBlocks(topmostIf))
{
if (block == selectedBlock)
{
continue;
}
else if (EmbeddedStatement.IsEmbeddableBlock(block))
{
success = true;
}
else
{
return(false);
}
}
return(success);
}
public static void ResolveAssignmentStatement(AssignmentStatement assignment, Table.Table table)
{
EmbeddedStatement body = (EmbeddedStatement)assignment.GetParentByType(typeof(EmbeddedStatement));
ResolveExpression(assignment.AdressableExpression, table);
if (assignment.AdressorExpressions.Length > 1)
{
foreach (IdentifierExpression identifier in assignment.AdressorExpressions)
{
ResolveIdentifierExpression(identifier, table, body);
TableIdentifier tableIdentifier = table.FetchIdentifier(identifier.Name);
if (tableIdentifier.IsGlobal)
{
tableIdentifier.InitializedGlobally = true;
}
}
}
else
{
ResolveAdressor(assignment.AdressorExpressions[0], body, table);
}
}
public static void ComputeRefactoring(RefactoringContext context, BlockSyntax block)
{
if (context.IsAnyRefactoringEnabled(
RefactoringIdentifiers.RemoveStatement,
RefactoringIdentifiers.DuplicateStatement,
RefactoringIdentifiers.CommentOutStatement))
{
StatementSyntax statement = GetStatement(context, block, block.Parent);
if (statement != null)
{
if (!EmbeddedStatement.IsEmbeddedStatement(statement) &&
statement.IsParentKind(SyntaxKind.Block))
{
RegisterRefactoring(context, statement);
}
if (context.IsRefactoringEnabled(RefactoringIdentifiers.CommentOutStatement))
{
CommentOutRefactoring.RegisterRefactoring(context, statement);
}
}
}
}
public override string ToString()
{
return($"do\n{EmbeddedStatement.ToStringWithTrailNL()}while ({Condition})");
}
private static bool CanRefactor(RefactoringContext context, StatementSyntax statement)
{
return(context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(statement) &&
EmbeddedStatement.IsEmbeddedStatement(statement));
}
public static void ResolveIdentifierExpression(IdentifierExpression identifier, Table.Table table, EmbeddedStatement initializedInBlock, bool checkInit = true)
{
if (identifier.IdentifierState == IdentifierExpression.State.Decl)
{
if (!table.PushIdentifier(identifier, table == GlobalTable.Table ? true : false))
{
ReportError(new IdentifierIsAlreadyDeclared(identifier.Name, identifier.SourceContext));
}
if (initializedInBlock != null)
{
table.InitializeInBlock(identifier, initializedInBlock);
}
}
else
{
if (!table.CheckIdentifier(identifier.Name))
{
ReportError(new IdentifierIsNotDeclared(identifier.Name, identifier.SourceContext));
}
else
{
TableIdentifier tableIdentifier = table.FetchIdentifier(identifier.Name);
identifier.Type = tableIdentifier.Type;
//check for initialization in this block
if (!table.IsInitializedInBlock(identifier, initializedInBlock) && checkInit && !tableIdentifier.InitializedGlobally)
{
ReportError(new IdentifierIsNotInitialized(identifier.Name, identifier.SourceContext));
}
}
}
}
