private static SyntaxKind GetReplacementKind(
ReturnStatementSyntax returnStatement,
ISymbol containingSymbol,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
SyntaxToken returnKeyword = returnStatement.ReturnKeyword;
ExpressionSyntax expression = returnStatement.Expression;
if (semanticModel.ContainsCompilerDiagnostic(CSharpErrorCodes.CannotImplicitlyConvertType, expression.Span, cancellationToken))
{
return(SyntaxKind.YieldReturnStatement);
}
else if (semanticModel.ContainsCompilerDiagnostic(CSharpErrorCodes.CannotReturnValueFromIterator, returnKeyword.Span, cancellationToken))
{
ITypeSymbol typeSymbol = semanticModel.GetTypeSymbol(expression, cancellationToken);
containingSymbol = containingSymbol ?? semanticModel.GetEnclosingSymbol(returnStatement.SpanStart, cancellationToken);
if (containingSymbol?.IsKind(SymbolKind.Method) == true)
{
var methodSymbol = (IMethodSymbol)containingSymbol;
ITypeSymbol returnType = methodSymbol.ReturnType;
if (returnType.SpecialType == SpecialType.System_Collections_IEnumerable)
{
if (typeSymbol.IsIEnumerableOrConstructedFromIEnumerableOfT())
{
return(SyntaxKind.ForEachStatement);
}
else
{
return(SyntaxKind.YieldReturnStatement);
}
}
else if (returnType.IsNamedType())
{
var namedTypeSymbol = (INamedTypeSymbol)returnType;
if (namedTypeSymbol.ConstructedFrom.SpecialType == SpecialType.System_Collections_Generic_IEnumerable_T)
{
if (semanticModel
.ClassifyConversion(expression, namedTypeSymbol.TypeArguments[0])
.IsImplicit)
{
return(SyntaxKind.YieldReturnStatement);
}
else
{
return(SyntaxKind.ForEachStatement);
}
}
}
}
}
return(SyntaxKind.None);
}
void ExportStatement(ReturnStatementSyntax ss)
{
var node = new ULStatementReturn();
node.Parent = currentBlock;
node.Arg = ExportExp(ss.Expression).GetOutputName(0);
currentBlock.statements.Add(node);
}
public override void VisitReturnStatement(ReturnStatementSyntax node)
{
m_ExistReturn = true;
if (m_InLoop > 0 || m_InSwitch > 0)
{
m_ExistReturnInLoopOrSwitch = true;
}
}
public override void VisitReturnStatement(ReturnStatementSyntax node)
{
_writer.Write(" return ");
base.VisitReturnStatement(node);
_writer.WriteLine(";");
}
public override SyntaxNode VisitReturnStatement(ReturnStatementSyntax node)
{
if (RemoveTestTriviaAnnotation(node.GetLeadingTrivia()))
{
return(null);
}
return(base.VisitReturnStatement(node));
}
public override IEnumerable <MutantInfo> VisitReturnStatement(ReturnStatementSyntax node)
{
if (node.Expression != null)
{
return(GenerateExpressionMutants(node.Expression, lineID));
}
return(new List <MutantInfo>());
}
public override void VisitReturnStatement(ReturnStatementSyntax node)
{
if (currentMethod != null)
{
currentMethod.cyclomaticComplexity++;
}
base.VisitReturnStatement(node);
}
public override IEnumerable <IModel> VisitReturnStatement(ReturnStatementSyntax node)
{
var model = Create <ReturnStatement>(node);
model.Expression = TransformToSingleOrNull <ExpressionModel>(node.Expression);
yield return(model);
}
private static void ReturnStatementExpressionCheck(ReturnStatementSyntax returnStatementExpression, SemanticModel semanticModel, Action <Diagnostic> reportDiagnostic, string filePath, CancellationToken cancellationToken)
{
if (returnStatementExpression.Expression != null)
{
var returnConversionInfo = semanticModel.GetConversion(returnStatementExpression.Expression, cancellationToken);
CheckTypeConversion(returnConversionInfo, reportDiagnostic, returnStatementExpression.Expression.GetLocation(), filePath);
}
}
public override void VisitReturnStatement(ReturnStatementSyntax node)
{
base.VisitReturnStatement(node);
if (node.Expression != null)
{
_counter++;
}
}
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);
}
}
}
private static void Analyze(SyntaxNodeAnalysisContext context)
{
PropertyDeclarationSyntax property = (PropertyDeclarationSyntax)context.Node;
if (property.Type.ToString() != @"TestContext")
{
return;
}
ITypeSymbol symbol = context.SemanticModel.GetSymbolInfo(property.Type).Symbol as ITypeSymbol;
if ((symbol == null) || (symbol.ToString() != @"Microsoft.VisualStudio.TestTools.UnitTesting.TestContext"))
{
return;
}
string varName = string.Empty;
string propName = property.Identifier.ToString();
IEnumerable <SyntaxNode> propNodes = context.Node.DescendantNodes();
IEnumerable <ReturnStatementSyntax> returnNodes = propNodes.OfType <ReturnStatementSyntax>();
if (returnNodes.Count() > 0)
{
ReturnStatementSyntax returnStatement = returnNodes.First();
if (returnStatement != null)
{
IdentifierNameSyntax returnVar = returnStatement.Expression as IdentifierNameSyntax;
if (returnVar != null)
{
varName = returnVar.Identifier.ToString();
}
}
}
// find out if the property or its underlying variable is actually used
foreach (IdentifierNameSyntax identifier in context.Node.Parent.DescendantNodes().OfType <IdentifierNameSyntax>())
{
if ((identifier.Identifier.ToString() == propName) && (identifier.Parent != property) &&
!(context.SemanticModel.GetSymbolInfo(identifier).Symbol is ITypeSymbol))
{
// if we find the same identifier as the propery and it's not a type or the original instance, it's used
return;
}
if ((identifier.Identifier.ToString() == varName) && !(identifier.Parent is VariableDeclarationSyntax) &&
!propNodes.Contains(identifier) && !(context.SemanticModel.GetSymbolInfo(identifier).Symbol is ITypeSymbol))
{
// if we find the same identifier as the variable and it's not a type, the original declaration, or part of the property, it's used
return;
}
}
// if not, report a diagnostic error
Diagnostic diagnostic = Diagnostic.Create(Rule, context.Node.GetLocation());
context.ReportDiagnostic(diagnostic);
return;
}
public override void VisitReturnStatement(ReturnStatementSyntax node)
{
Debug.Assert(_returningPoint.Count > 0);
if (node.Expression != null)
{
_graph.AddEdge(node.Expression, SourceGraphEdge.ReturnsTo, _returningPoint.Peek());
}
base.VisitReturnStatement(node);
}
private async Task <Document> GenerateExplicitConversion(Document document, ReturnStatementSyntax returnStatement, CancellationToken cancellationToken)
{
var(mappingEngine, semanticModel) = await CreateMappingEngine(document, returnStatement, cancellationToken);
var returnExpressionTypeInfo = mappingEngine.GetExpressionTypeInfo(returnStatement.Expression);
var mappingExpression = mappingEngine.MapExpression(returnStatement.Expression !.WithoutTrivia(), returnExpressionTypeInfo.GetAnnotatedType(), returnExpressionTypeInfo.GetAnnotatedTypeForConverted(), new MappingContext(returnStatement, semanticModel));
return(await ReplaceNode(document, returnStatement, returnStatement.WithExpression(mappingExpression), cancellationToken));
}
public override void VisitReturnStatement(ReturnStatementSyntax node)
{
LastStatement = new ApexReturnStatementSyntax
{
LeadingComments = GetLeadingAndNoApexComments(node),
TrailingComments = Comments.Trailing(node),
Expression = ConvertExpression(node.Expression),
};
}
private void RunReturn(ReturnStatementSyntax node)
{
if (node.Expression != null)
{
Ret = RunExpression(node.Expression);
}
Halt = HaltType.Return;
}
public override void VisitReturnStatement(ReturnStatementSyntax node)
{
if (node.Expression != null)
{
Visit(node.Expression);
}
_returningFromCx.Peek().UnionWith(_currentPathParents);
_currentPathParents = new HashSet <int>();
}
private static BlockSyntax CreateBlockWithReturnStatement(ExpressionSyntax expression, SyntaxToken semicolon)
{
ReturnStatementSyntax returnStatement = ReturnStatement(
ReturnKeyword().WithLeadingTrivia(expression.GetLeadingTrivia()),
expression.WithoutLeadingTrivia(),
semicolon);
return(Block(returnStatement));
}
public override void VisitReturnStatement(ReturnStatementSyntax node)
{
if (entryPoint.IsMethodLevel() && node.IsParent <AnonymousFunctionExpressionSyntax>())
{
return;
}
noscounter++;
base.VisitReturnStatement(node);
}
private async Task <Document> GenerateExplicitConversion(Document document, ReturnStatementSyntax returnStatement, CancellationToken cancellationToken)
{
var mappingEngine = await CreateMappingEngine(document, returnStatement, cancellationToken);
var returnExpressionTypeInfo = mappingEngine.GetExpressionTypeInfo(returnStatement.Expression);
var mappingExpression = mappingEngine.MapExpression(returnStatement.Expression, returnExpressionTypeInfo.Type, returnExpressionTypeInfo.ConvertedType);
return(await ReplaceNode(document, returnStatement, returnStatement.WithExpression(mappingExpression), cancellationToken));
}
public override void VisitReturnStatement(ReturnStatementSyntax node)
{
if (node.Expression != null)
{
var patternBinder = new PatternVariableBinder(node, _enclosing);
AddToMap(node, patternBinder);
Visit(node.Expression, patternBinder);
}
}
public override SyntaxNode VisitReturnStatement(ReturnStatementSyntax node)
{
if (!node.DescendantNodes().Any())
{
return(base.VisitReturnStatement(node));
}
if (node.DescendantNodes().First() is LiteralExpressionSyntax literlaExpression)
{
SyntaxNode newNode = null;
if (literlaExpression.IsKind(SyntaxKind.TrueLiteralExpression))
{
newNode = node.ReplaceNode(literlaExpression, SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression, SyntaxFactory.Token(SyntaxKind.FalseKeyword)));
}
if (literlaExpression.IsKind(SyntaxKind.FalseLiteralExpression))
{
newNode = node.ReplaceNode(literlaExpression, SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression, SyntaxFactory.Token(SyntaxKind.TrueKeyword)));
}
if (literlaExpression.IsKind(SyntaxKind.NullLiteralExpression))
{
newNode = node.Parent.ReplaceNode(node.Parent, SyntaxFactory.ThrowStatement(SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName($"System.{typeof(Exception).Name}")).WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList <ArgumentSyntax>(SyntaxFactory.Argument(SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("Mmmmutation"))))))));
}
if (literlaExpression.IsKind(SyntaxKind.StringLiteralExpression))
{
newNode = node.ReplaceNode(literlaExpression, SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal("Mutation")));
}
if (literlaExpression.IsKind(SyntaxKind.NumericLiteralExpression))
{
if (double.TryParse(literlaExpression.Token.Value.ToString(), out var value))
{
value = value == 0 ? 1 : 0;
newNode = node.ReplaceNode(literlaExpression, SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(value)));
}
}
if (newNode != null)
{
newNode = newNode.NormalizeWhitespace();
Replacers.Add(new MutationDocumentDetails(node, newNode, GetWhere(node)));
}
}
var objectCreationExpressions = node.DescendantNodes().OfType <ObjectCreationExpressionSyntax>().ToList();
foreach (var objectCreationExpressionSyntax in objectCreationExpressions)
{
var newNode = node.ReplaceNode(objectCreationExpressionSyntax, SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression));
Replacers.Add(new MutationDocumentDetails(node, newNode, GetWhere(node)));
}
return(base.VisitReturnStatement(node));
}
public override SyntaxNode VisitReturnStatement(ReturnStatementSyntax node)
{
// If we have only a return statement rewrite it to a return Task.CompletedTask
if (node.Expression == null)
{
return(GetReturnTaskCompleted().WithTriviaFrom(node));
}
return(base.VisitReturnStatement(node));
}
public static bool CanRefactor(ReturnStatementSyntax returnStatement, SemanticModel semanticModel, CancellationToken cancellationToken)
{
ExpressionSyntax expression = returnStatement.Expression;
return(expression?.IsMissing == false &&
semanticModel
.GetTypeSymbol(expression, cancellationToken)?
.IsVoid() == true);
}
public override void VisitReturnStatement(ReturnStatementSyntax node)
{
if (node.Expression is { } expression)
{
this.returnValues.Add(expression);
}
base.VisitReturnStatement(node);
}
public void Render(ReturnStatementSyntax returnStatement)
{
Render(returnStatement.ReturnKeywordToken);
if (returnStatement.EmptyExpressionNode is null)
{
WriteSpace();
Render(returnStatement.ExpressionNode);
}
}
protected override SyntaxNode Revert(BaseMethodDeclarationSyntax node)
{
// get expression
var expression = SyntaxFactory.ArrowExpressionClause(node.Body?.Statements[0] switch
{
ReturnStatementSyntax returnStatement => returnStatement.Expression,
ExpressionStatementSyntax expressionStatement => expressionStatement.Expression,
_ => throw new InvalidOperationException($"Can't extract original expression from {node.Body}")
});
public override void VisitReturnStatement(ReturnStatementSyntax node)
{
MethodInfo mi = m_MethodInfoStack.Peek();
mi.ExistTopLevelReturn = IsLastNodeOfMethod(node);
bool isLastNode = IsLastNodeOfParent(node);
if (!isLastNode)
{
CodeBuilder.AppendFormat("{0}do", GetIndentString());
CodeBuilder.AppendLine();
}
string prestr;
if (mi.SemanticInfo.MethodKind == MethodKind.Constructor)
{
CodeBuilder.AppendFormat("{0}return this", GetIndentString());
prestr = ", ";
}
else
{
CodeBuilder.AppendFormat("{0}return ", GetIndentString());
prestr = string.Empty;
}
if (null != node.Expression)
{
CodeBuilder.Append(prestr);
IConversionExpression opd = null;
var iret = m_Model.GetOperation(node) as IReturnStatement;
if (null != iret)
{
opd = iret.ReturnedValue as IConversionExpression;
}
OutputExpressionSyntax(node.Expression, opd);
prestr = ", ";
}
var names = mi.ReturnParamNames;
if (names.Count > 0)
{
for (int i = 0; i < names.Count; ++i)
{
CodeBuilder.Append(prestr);
CodeBuilder.Append(names[i]);
prestr = ", ";
}
}
CodeBuilder.AppendLine(";");
if (!isLastNode)
{
CodeBuilder.AppendFormat("{0}end;", GetIndentString());
CodeBuilder.AppendLine();
}
}
private SyntaxNode FindStatementToReplace(SyntaxNode node)
{
return(node switch
{
//TODO EqualsValueClauseSyntax - Type1 v = vOfType2
AssignmentExpressionSyntax assignmentStatement => assignmentStatement,
ReturnStatementSyntax returnStatement => returnStatement,
YieldStatementSyntax yieldStatement => yieldStatement,
_ => node.Parent == null ? null : FindStatementToReplace(node.Parent),
});
/// <summary>
/// Visits a return statement
/// </summary>
/// <param name="node">The return statement syntax</param>
public override void VisitReturnStatement(ReturnStatementSyntax node)
{
foreach (SyntaxNode subNode in node.ChildNodes())
{
_retType = FromSyntaxNode(subNode);
// TODO: This will return the first return type, which could
// be different than other return types. I will not care yet
break;
}
}
public override void VisitReturnStatement(ReturnStatementSyntax node)
{
((List<ReturnStatementSyntax>)Results).Add(node);
base.VisitReturnStatement(node);
}
public virtual void VisitReturnStatement(ReturnStatementSyntax node)
{
DefaultVisit(node);
}
private BoundReturnStatement BindReturnStatement(ReturnStatementSyntax syntax)
{
BindAttributes(syntax.Attributes);
return new BoundReturnStatement(syntax.Expression != null ? Bind(syntax.Expression, BindExpression) : null);
}
private BoundReturnStatement BindReturnStatement(ReturnStatementSyntax syntax)
{
var boundExpression = BindExpression(syntax.Expression);
return new BoundReturnStatement(boundExpression, syntax);
}
public static ReturnStatementSyntax ReturnStatement(ExpressionSyntax expression = null)
{
var result = new ReturnStatementSyntax();
result.Expression = expression;
return result;
}
public BoundReturnStatement(BoundExpression expression, ReturnStatementSyntax syntax)
: base(syntax)
{
Expression = expression;
}
private Method TraverseReturnStatement(ReturnStatementSyntax rss)
{
Method retMethod = new Method();
foreach (SyntaxNode sn in rss.ChildNodes())
{
if (sn is CallStatementSyntax)
{
retMethod.InvokedMethods.Add(TraverseInvokedMethod(sn as CallStatementSyntax));
}
else if (sn is InvocationExpressionSyntax)
{
retMethod.InvokedMethods.Add(TraverseInvokedMethod(sn as InvocationExpressionSyntax));
}
else if (sn is LocalDeclarationStatementSyntax)
{
Method tempMethod = TraverseVarDecls(sn as LocalDeclarationStatementSyntax);
retMethod.AccessedVariables.AddRange(tempMethod.AccessedVariables);
retMethod.InvokedMethods.AddRange(tempMethod.InvokedMethods);
}
else if (sn is AssignmentStatementSyntax)
{
Method tempMethod = TraverseAccessVars(sn as AssignmentStatementSyntax);
retMethod.AccessedVariables.AddRange(tempMethod.AccessedVariables);
retMethod.InvokedMethods.AddRange(tempMethod.InvokedMethods);
}
}
return retMethod;
}
public void VisitReturnStatement(ReturnStatementSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
WriteLeadingTrivia(node);
_writer.WriteIndent();
_writer.WriteKeyword(PrinterKeyword.Return);
if (node.Expression != null)
{
_writer.WriteSpace();
node.Expression.Accept(this);
}
_writer.EndStatement();
WriteTrailingTrivia(node);
}
protected override SyntaxNode VisitReturnStatement(ReturnStatementSyntax node)
{
if (node.ExpressionOpt == null)
return base.VisitReturnStatement (node);
return node.Update (node.ReturnKeyword, GetReturnExpression (this.currentMethod.Identifier.ValueText, node.ExpressionOpt.ToString()), node.SemicolonToken);
}
public override void VisitReturnStatement(ReturnStatementSyntax node)
{
_writer.Write(" return ");
base.VisitReturnStatement(node);
_writer.WriteLine(";");
}
protected override void CompileReturnStatement(ReturnStatementSyntax statement)
{
if (CurrentMethod == Compiling.FragmentMethod)
{
BeginLine("__FinalOutput.Color{0}={0}", Space);
CompileExpression(statement.Expression);
EndLine(";");
WriteLine("return __FinalOutput;");
}
else
{
base.CompileReturnStatement(statement);
}
}
public BoundReturnStatement(ReturnStatementSyntax syntax, BoundExpression expressionOpt)
: base(BoundNodeKind.ReturnStatement, syntax)
{
ExpressionOpt = expressionOpt;
}
public void Flatten(ReturnStatementSyntax node, List<FlatStatement> instructions)
{
if (node.Expression != null)
{
if (this.MethodSymbol.ReturnsVoid)
{
throw new NotImplementedException("returning a value from a void function");
}
FlatOperand fop_return = ResolveExpression(node.Expression, null, instructions);
instructions.Add(FlatStatement.REREFERENCE(FlatOperand.InputRef(0, FlatValue.Null()),fop_return));
}
instructions.Add(FlatStatement.RETURN());
}
public void SetReturnStatement(SyntaxNode statement)
{
this.statement = (ReturnStatementSyntax) statement;
}
public virtual void Visit(ReturnStatementSyntax returnStatementSyntax)
{
Visit(returnStatementSyntax.Expression);
}
public override SyntaxNode VisitReturnStatement(ReturnStatementSyntax node)
{
var based = base.VisitReturnStatement (node);
based = based.WithTrailingTrivia (based.GetTrailingTrivia().Prepend (GetIdComment()));
return based;
}
protected abstract void CompileReturnStatement(ReturnStatementSyntax statement);
