public override SyntaxNode VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
node = (PostfixUnaryExpressionSyntax)base.VisitPostfixUnaryExpression(node);
if (transformKind == TransformKind.PostfixToPrefix)
{
var operatorToken = node.OperatorToken;
var operand = node.Operand;
var newOperatorToken = SyntaxFactory.Token(operand.GetLeadingTrivia(), operatorToken.Kind(), SyntaxFactory.TriviaList(SyntaxFactory.ElasticMarker));
var newOperand = operand.WithLeadingTrivia(operatorToken.LeadingTrivia);
newOperand = newOperand.WithTrailingTrivia(operatorToken.TrailingTrivia);
if (node.Kind() == SyntaxKind.PostIncrementExpression)
{
return(SyntaxFactory.PrefixUnaryExpression(SyntaxKind.PreIncrementExpression, newOperatorToken, newOperand));
}
if (node.Kind() == SyntaxKind.PostDecrementExpression)
{
return(SyntaxFactory.PrefixUnaryExpression(SyntaxKind.PreDecrementExpression, newOperatorToken, newOperand));
}
}
return(node);
}
/// <summary>
/// 7.6.9
/// </summary>
public override void VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
LLVMValueRef operand;
LLVMOpcode opcode;
LLVMValueRef opValue;
TypeInfo typeInfo = this.semanticModel.GetTypeInfo(node.Operand);
switch (typeInfo.ConvertedType.SpecialType)
{
case SpecialType.System_SByte:
case SpecialType.System_Byte:
case SpecialType.System_Int16:
case SpecialType.System_UInt16:
case SpecialType.System_Int32:
case SpecialType.System_UInt32:
case SpecialType.System_Int64:
case SpecialType.System_UInt64:
case SpecialType.System_Char:
opcode = node.Kind() == SyntaxKind.PostIncrementExpression ? LLVMOpcode.LLVMAdd : LLVMOpcode.LLVMSub;
opValue = LLVM.ConstInt(typeInfo.LLVMTypeRef(), 1, typeInfo.IsSignExtended());
break;
case SpecialType.System_Single:
case SpecialType.System_Double:
case SpecialType.System_Decimal:
opcode = node.Kind() == SyntaxKind.PostIncrementExpression ? LLVMOpcode.LLVMFAdd : LLVMOpcode.LLVMFSub;
opValue = LLVM.ConstReal(typeInfo.LLVMTypeRef(), 1);
break;
default:
throw new NotImplementedException("PostIncrementExpression/PostDecrementExpression overloading is not yet implemented");
}
switch (node.Operand.Kind())
{
case SyntaxKind.IdentifierName:
SyntaxNode syntaxNode = node.Operand.DeclaringSyntaxNode(this.semanticModel);
operand = this.symbolTable[syntaxNode];
break;
case SyntaxKind.SimpleMemberAccessExpression:
throw new NotImplementedException("PostIncrementExpression/PostDecrementExpression for SimpleMemberAccessExpression is not implemented");
case SyntaxKind.ElementAccessExpression:
throw new NotImplementedException("PostIncrementExpression/PostDecrementExpression for ElementAccessExpression is not implemented");
default:
throw new Exception("Unreachable");
}
this.Visit(node.Operand);
var inc = LLVM.BuildBinOp(this.builder, opcode, this.valueStack.Peek(), opValue, "postop");
LLVM.BuildStore(this.builder, inc, operand);
}
private static ITranslationUnit BuildUnaryExpressionTranslationUnit(PostfixUnaryExpressionSyntax expression, SemanticModel semanticModel)
{
OperatorToken token = OperatorToken.Undefined;
switch (expression.Kind())
{
case SyntaxKind.PostIncrementExpression:
token = OperatorToken.Increment;
break;
case SyntaxKind.PostDecrementExpression:
token = OperatorToken.Decrement;
break;
}
if (token == OperatorToken.Undefined)
{
throw new InvalidOperationException("Unary operator could not be detected!");
}
UnaryExpression unaryExpressionHelper = new UnaryExpression(expression, semanticModel);
ITranslationUnit operand = new ExpressionTranslationUnitBuilder(unaryExpressionHelper.Operand, semanticModel).Build();
return(UnaryExpressionTranslationUnit.Create(operand, token, UnaryExpressionTranslationUnit.UnaryPosition.Postfix));
}
public override AccessorOrMutator VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
var operand = Visit(node.Operand);
switch (node.Kind())
{
case SyntaxKind.PostIncrementExpression:
case SyntaxKind.PostDecrementExpression:
{
var accessor = operand as Accessor;
if (accessor != null)
{
var methodSymbol = Model.GetSymbolInfo(node).Symbol as IMethodSymbol;
if (methodSymbol != null)
{
var value = operand.GetMutator(this);
var result = Lifter.LiftInstanceNonVoidNullaryMethod(methodSymbol)(accessor.GetMutator(this));
accessor.AcceptAssignment(this, result.Item1);
return(value); // Return the value before the assignment
}
}
break;
}
}
throw new SyntaxErrorException("Unsupported syntax: " + node);
}
public override async Task ComputeRefactoringsAsync(CodeRefactoringContext context)
{
SyntaxNode root = await context.Document.GetSyntaxRootAsync(context.CancellationToken);
PostfixUnaryExpressionSyntax postfixUnaryExpression = root
.FindNode(context.Span, getInnermostNodeForTie: true)?
.FirstAncestorOrSelf <PostfixUnaryExpressionSyntax>();
if (postfixUnaryExpression == null)
{
return;
}
switch (postfixUnaryExpression.Kind())
{
case SyntaxKind.PostIncrementExpression:
{
PostIncrementToPreIncrement(context, postfixUnaryExpression);
PostIncrementToPostDecrement(context, postfixUnaryExpression);
break;
}
case SyntaxKind.PostDecrementExpression:
{
PostDecrementToPreDecrement(context, postfixUnaryExpression);
PostDecrementToPostIncrement(context, postfixUnaryExpression);
break;
}
}
}
private void CreateReplacer(PostfixUnaryExpressionSyntax node, PostfixUnaryExpressionSyntax newNode)
{
Replacers.Add(new MutationDocumentDetails(
node,
newNode,
GetWhere(node),
CreateCategory(node.Kind().ToString())));
}
public static void Write(PostfixUnaryExpressionSyntax syntax, IIndentedTextWriterWrapper textWriter, IContext context)
{
var operand = "";
if (syntax.Kind() == SyntaxKind.PostIncrementExpression)
{
operand = "+";
}
else if (syntax.Kind() == SyntaxKind.PostDecrementExpression)
{
operand = "-";
}
syntax.Operand.Write(textWriter, context);
textWriter.Write(" = ");
syntax.Operand.Write(textWriter, context);
textWriter.Write($" {operand} 1");
}
public Statement GetStatement()
{
var statement = new UnaryStatement
{
Operand = statementInterpreterHandler.GetStatement(postfixUnaryExpressionSyntax.Operand)
};
switch (postfixUnaryExpressionSyntax.Kind())
{
case Microsoft.CodeAnalysis.CSharp.SyntaxKind.PostDecrementExpression:
statement.Operator = UnaryOperand.PostDecrementAssign;
break;
case Microsoft.CodeAnalysis.CSharp.SyntaxKind.PostIncrementExpression:
statement.Operator = UnaryOperand.PostIncrementAssign;
break;
default:
throw new NotSupportedException(postfixUnaryExpressionSyntax.Kind() + " is not supported unary operation");
}
return(statement);
}
public static void ComputeRefactorings(RefactoringContext context, PostfixUnaryExpressionSyntax postfixUnaryExpression)
{
SyntaxKind kind = postfixUnaryExpression.Kind();
if (kind == SyntaxKind.PostIncrementExpression)
{
ReplacePostIncrementWithPreIncrement(context, postfixUnaryExpression);
ReplacePostIncrementWithPostDecrement(context, postfixUnaryExpression);
}
else if (kind == SyntaxKind.PostDecrementExpression)
{
ReplacePostDecrementWithPreDecrement(context, postfixUnaryExpression);
ReplacePostDecrementWithPostIncrement(context, postfixUnaryExpression);
}
}
public static void ComputeRefactorings(RefactoringContext context, PostfixUnaryExpressionSyntax postfixUnaryExpression)
{
if (!context.Span.IsEmptyAndContainedInSpanOrBetweenSpans(postfixUnaryExpression.OperatorToken))
{
return;
}
switch (postfixUnaryExpression.Kind())
{
case SyntaxKind.PostIncrementExpression:
{
InvertPostIncrement(context, postfixUnaryExpression);
ReplacePostIncrementWithPreIncrement(context, postfixUnaryExpression);
break;
}
case SyntaxKind.PostDecrementExpression:
{
InvertPostDecrement(context, postfixUnaryExpression);
ReplacePostDecrementWithPreDecrement(context, postfixUnaryExpression);
break;
}
}
}
private IEnumerable<ITypeSymbol> InferTypeInPostfixUnaryExpression(PostfixUnaryExpressionSyntax postfixUnaryExpressionSyntax, SyntaxToken? previousToken = null)
{
// If we're after a postfix ++ or -- then we can't infer anything.
if (previousToken.HasValue)
{
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
switch (postfixUnaryExpressionSyntax.Kind())
{
case SyntaxKind.PostDecrementExpression:
case SyntaxKind.PostIncrementExpression:
return SpecializedCollections.SingletonEnumerable(this.Compilation.GetSpecialType(SpecialType.System_Int32));
}
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
public override SyntaxNode VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
if (node.IsKind(SK.PostIncrementExpression) ||
node.IsKind(SK.PostDecrementExpression))
{
var identifier = ((IdentifierNameSyntax)node.Operand).Identifier.Text;
SMS.Update(identifier, node);
}
else
{
throw new NotImplementedException("Unsupported PostfixUnaryExpression: " + node.Kind());
}
return(base.VisitPostfixUnaryExpression(node));
}
public override SyntaxNode VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
node = (PostfixUnaryExpressionSyntax)base.VisitPostfixUnaryExpression(node);
if (transformKind == TransformKind.PostfixToPrefix)
{
var operatorToken = node.OperatorToken;
var operand = node.Operand;
var newOperatorToken = SyntaxFactory.Token(operand.GetLeadingTrivia(), operatorToken.Kind(), SyntaxFactory.TriviaList(SyntaxFactory.ElasticMarker));
var newOperand = operand.WithLeadingTrivia(operatorToken.LeadingTrivia);
newOperand = newOperand.WithTrailingTrivia(operatorToken.TrailingTrivia);
if (node.Kind() == SyntaxKind.PostIncrementExpression)
{
return SyntaxFactory.PrefixUnaryExpression(SyntaxKind.PreIncrementExpression, newOperatorToken, newOperand);
}
if (node.Kind() == SyntaxKind.PostDecrementExpression)
{
return SyntaxFactory.PrefixUnaryExpression(SyntaxKind.PreDecrementExpression, newOperatorToken, newOperand);
}
}
return node;
}