private SyntaxResult <SyntaxNode> TranslateStatement_Return(ReturnStatement returnStatement, TranslatorState state)
{
ReturnStatementSyntax returnStatementSyntax = SyntaxFactory.ReturnStatement();
if (returnStatement.Expression != null)
{
var expression = TranslateExpression(returnStatement.Expression, state);
if (expression.IsError)
{
returnStatementSyntax = returnStatementSyntax.WithTrailingTrivia(expression.Errors);
}
else
{
returnStatementSyntax = returnStatementSyntax.WithExpression(expression.Syntax);
}
}
return(returnStatementSyntax);
}
private static async Task <StatementListInfo> RefactorAsync <TStatement>(
Document document,
TStatement statement,
StatementListInfo statementsInfo,
Func <TStatement, TStatement> createNewStatement,
int count,
bool removeReturnStatement,
CancellationToken cancellationToken) where TStatement : StatementSyntax
{
int statementIndex = statementsInfo.IndexOf(statement);
var returnStatement = (ReturnStatementSyntax)statementsInfo[statementIndex + 1];
ExpressionSyntax returnExpression = returnStatement.Expression;
ExpressionSyntax newReturnExpression = null;
SyntaxTriviaList newTrailingTrivia = default;
SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
ISymbol symbol = semanticModel.GetSymbol(returnExpression, cancellationToken);
if (symbol.Kind == SymbolKind.Local &&
statementIndex > 0 &&
statementsInfo[statementIndex - 1] is LocalDeclarationStatementSyntax localDeclarationStatement &&
!localDeclarationStatement.ContainsDiagnostics &&
!localDeclarationStatement.SpanOrTrailingTriviaContainsDirectives() &&
!statement.GetLeadingTrivia().Any(f => f.IsDirective))
{
SeparatedSyntaxList <VariableDeclaratorSyntax> declarators = localDeclarationStatement.Declaration.Variables;
VariableDeclaratorSyntax declarator = declarators.FirstOrDefault(f => semanticModel.GetDeclaredSymbol(f, cancellationToken)?.Equals(symbol) == true);
if (declarator != null)
{
ExpressionSyntax value = declarator.Initializer?.Value;
if (removeReturnStatement || value != null)
{
IEnumerable <ReferencedSymbol> referencedSymbols = await SymbolFinder.FindReferencesAsync(symbol, document.Solution(), cancellationToken).ConfigureAwait(false);
if (referencedSymbols.First().Locations.Count() == count + 1)
{
newReturnExpression = value;
if (declarators.Count == 1)
{
if (!removeReturnStatement &&
returnStatement.GetTrailingTrivia().IsEmptyOrWhitespace())
{
SyntaxTriviaList trailingTrivia = localDeclarationStatement.GetTrailingTrivia();
if (trailingTrivia
.SkipWhile(f => f.IsWhitespaceTrivia())
.FirstOrDefault()
.IsKind(SyntaxKind.SingleLineCommentTrivia))
{
newTrailingTrivia = trailingTrivia;
}
}
SyntaxRemoveOptions removeOptions = SyntaxRefactorings.GetRemoveOptions(localDeclarationStatement);
if (newTrailingTrivia.Any())
{
removeOptions &= ~SyntaxRemoveOptions.KeepTrailingTrivia;
}
statementsInfo = statementsInfo.RemoveNode(localDeclarationStatement, removeOptions);
statementIndex--;
}
else
{
statementsInfo = statementsInfo.ReplaceNode(localDeclarationStatement, localDeclarationStatement.RemoveNode(declarator, SyntaxRefactorings.GetRemoveOptions(declarator)));
}
returnStatement = (ReturnStatementSyntax)statementsInfo[statementIndex + 1];
}
}
}
}
if (removeReturnStatement)
{
statementsInfo = statementsInfo.RemoveNode(returnStatement, SyntaxRefactorings.GetRemoveOptions(returnStatement));
}
else if (newReturnExpression != null)
{
ReturnStatementSyntax newReturnStatement = returnStatement.WithExpression(newReturnExpression.WithTriviaFrom(returnExpression));
if (newTrailingTrivia.Any())
{
newReturnStatement = newReturnStatement.WithTrailingTrivia(newTrailingTrivia);
}
statementsInfo = statementsInfo.ReplaceNode(returnStatement, newReturnStatement);
}
StatementSyntax oldNode = statementsInfo[statementIndex];
TStatement newNode = createNewStatement((TStatement)oldNode).WithFormatterAnnotation();
return(statementsInfo.ReplaceNode(oldNode, newNode));
}