private BoundExpression ProcessPostfixUnary(PostfixUnaryExpressionSyntax node)
{
var expression = BindExpression(node.Operand);
var operatorKind = SyntaxFacts.GetUnaryOperatorKind(node.Kind);
TypeSymbol expressionType;
switch (operatorKind)
{
case UnaryOperatorKind.LogicalNot:
expressionType = IntrinsicTypes.Bool;
break;
case UnaryOperatorKind.BitwiseNot:
expressionType = IntrinsicTypes.Uint;
break;
case UnaryOperatorKind.Plus:
case UnaryOperatorKind.Minus:
case UnaryOperatorKind.PostIncrement:
case UnaryOperatorKind.PostDecrement:
expressionType = expression.Type;
break;
default:
throw new ArgumentOutOfRangeException();
}
return(new BoundUnaryExpression(node, expression, operatorKind, expressionType));
}
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);
}
protected override object VisitPostIncrementExpression(PostfixUnaryExpressionSyntax node)
{
var a = _VisitExpression(node);
Debug.Assert(a is IStatement);
return(a);
}
private static bool ExpressionIsPreOrPostIncrement(
ExpressionSyntax node,
Action <SyntaxToken> found)
{
var tuple = node switch
{
PrefixUnaryExpressionSyntax pre
=> (pre.OperatorToken, pre.Operand),
PostfixUnaryExpressionSyntax post
=> (post.OperatorToken, post.Operand),
_ => ((SyntaxToken, ExpressionSyntax)?)null,
};
if (tuple is null)
{
return(false);
}
var(operatorToken, operand) = tuple.Value;
if (!operatorToken.IsKind(SyntaxKind.PlusPlusToken))
{
return(false);
}
if (!(operand is IdentifierNameSyntax idName))
{
return(false);
}
found(idName.Identifier);
return(true);
}
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;
}
}
}
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);
}
public override void VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
var operand = VisitSyntaxNode(node.Operand);
var @operator = node.OperatorToken.Text;
_currentNode = new PostfixUnaryExpression(operand, @operator);
}
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 BoundNode VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
MethodSymbol unaryMethodSymbol = (MethodSymbol)GetSymbol(node);
return(new BoundInvocationExpression.BoundPostfixOperatorExpression(Context, node,
(BoundAccessExpression)VisitExpression(node.Operand, unaryMethodSymbol.Parameters[0].Type), unaryMethodSymbol));
}
public override void VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
IncrementNodeCount(1); // only the `!` operator, which has no SQL equivalent
AddOperator(node.OperatorToken.ValueText);
base.VisitPostfixUnaryExpression(node);
}
public override void VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
var oper = m_Model.GetOperation(node) as IHasOperatorMethodExpression;
if (null != oper && oper.UsesOperatorMethod)
{
IMethodSymbol msym = oper.OperatorMethod;
InvocationInfo ii = new InvocationInfo();
var arglist = new List <ExpressionSyntax>()
{
node.Operand
};
ii.Init(msym, arglist, m_Model);
OutputOperatorInvoke(ii, node);
}
else
{
string op = node.OperatorToken.Text;
if (op == "++" || op == "--")
{
VisitExpressionSyntax(node.Operand);
m_PostfixUnaryExpressions.Enqueue(node);
}
else
{
CodeBuilder.Append("(");
CodeBuilder.Append(op);
CodeBuilder.Append(" ");
VisitExpressionSyntax(node.Operand);
CodeBuilder.Append(")");
}
}
}
public override SyntaxNode VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
var visitedNode = base.VisitPostfixUnaryExpression(node);
var instrumentedNode = Instrument(visitedNode as ExpressionSyntax);
return(instrumentedNode ?? visitedNode);
}
public static IdentifierNameSyntax FindIdentifierName(this ExpressionSyntax expression)
{
IdentifierNameSyntax name = expression as IdentifierNameSyntax;
if (name != null)
{
return(name);
}
BinaryExpressionSyntax binaryExpression = expression as BinaryExpressionSyntax;
if (binaryExpression != null)
{
return(FindIdentifierName(binaryExpression.Right));
}
PostfixUnaryExpressionSyntax postfixUnaryExpression = expression as PostfixUnaryExpressionSyntax;
if (postfixUnaryExpression != null)
{
return(FindIdentifierName(postfixUnaryExpression.Operand));
}
PrefixUnaryExpressionSyntax prefixUnaryExpression = expression as PrefixUnaryExpressionSyntax;
if (prefixUnaryExpression != null)
{
return(FindIdentifierName(prefixUnaryExpression.Operand));
}
return(null);
}
private ExpressionSyntax ParsePostFixExpression(ExpressionSyntax expr)
{
Debug.Assert(expr != null);
while (true)
{
var tk = Current.Kind;
switch (tk)
{
case SyntaxKind.OpenParenToken:
expr = new InvocationExpressionSyntax(expr, ParseParenthesizedArgumentList(false));
break;
case SyntaxKind.OpenBracketToken:
expr = new ElementAccessExpressionSyntax(expr,
Match(SyntaxKind.OpenBracketToken),
ParseExpression(),
Match(SyntaxKind.CloseBracketToken));
break;
case SyntaxKind.PlusPlusToken:
case SyntaxKind.MinusMinusToken:
expr = new PostfixUnaryExpressionSyntax(SyntaxFacts.GetPostfixUnaryExpression(tk), expr, NextToken());
break;
case SyntaxKind.DotToken:
expr = new MemberAccessExpressionSyntax(expr, NextToken(), ParseIdentifier());
break;
default:
return(expr);
}
}
}
public override SyntaxNode VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
SyntaxToken postFixUnaryOperator = node.OperatorToken;
SyntaxToken newToken = SyntaxFactory.Token(SyntaxKind.None);
// ++ becomes --
if (postFixUnaryOperator.IsKind(SyntaxKind.PlusPlusToken))
{
newToken = SyntaxFactory.Token(SyntaxKind.MinusMinusToken)
.WithTrailingTrivia(SyntaxFactory.Space);
}
// -- becomes ++
if (postFixUnaryOperator.IsKind(SyntaxKind.MinusMinusToken))
{
newToken = SyntaxFactory.Token(SyntaxKind.PlusPlusToken)
.WithTrailingTrivia(SyntaxFactory.Space);
}
if (!newToken.IsKind(SyntaxKind.None))
{
var mutatedBinaryExressionNode = node.ReplaceToken(postFixUnaryOperator, newToken);
var mutatedClassRoot = _classRootNode.ReplaceNode(node, mutatedBinaryExressionNode);
_mutantCreator.CreateNewMutant(mutatedClassRoot, false);
}
return(node);
}
private void CreateReplacer(PostfixUnaryExpressionSyntax node, PostfixUnaryExpressionSyntax newNode)
{
Replacers.Add(new MutationDocumentDetails(
node,
newNode,
GetWhere(node),
CreateCategory(node.Kind().ToString())));
}
public override SyntaxNode VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
var symbol = GetMonitorableSymbol(node.Operand);
return(symbol == null
? node
: InvokeAssignmentMonitor(symbol, node, node));
}
private Doc PrintPostfixUnaryExpressionSyntax(
PostfixUnaryExpressionSyntax node)
{
return(Concat(
this.Print(node.Operand),
this.PrintSyntaxToken(node.OperatorToken)
));
}
public override void VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
Expression = new PostfixUnaryExpressionCPPModel()
{
Operand = Invoke <ExpressionVisitor>(node.Operand).Expression,
Type = ToUnaryExpressionType(node, node.OperatorToken.ToString())
};
}
private static Task <Document> ChangePreDecrementToPostDecrementAsync(
Document document,
PrefixUnaryExpressionSyntax preDecrement,
PostfixUnaryExpressionSyntax postDecrement,
CancellationToken cancellationToken = default)
{
return(document.ReplaceNodeAsync(preDecrement, postDecrement, cancellationToken));
}
private ProgramState VisitPostfixIncrement(PostfixUnaryExpressionSyntax unary, ProgramState newProgramState)
{
var leftSymbol = SemanticModel.GetSymbolInfo(unary.Operand).Symbol;
// Do not change the stacked value
var sv = new SymbolicValue();
return(SetNewSymbolicValueIfLocal(leftSymbol, sv, newProgramState));
}
public override IEnumerable <IModel> VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
var model = Create <PostfixUnaryExpression>(node);
model.Operand = TransformToSingle <ExpressionModel>(node.Operand);
model.Operator = node.OperatorToken.ValueText;
yield return(model);
}
public override IStmt VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
return(new UnaryExpr
{
IsPrefixExpr = false,
Expression = Visit(node.Operand),
Operation = node.OperatorToken.Text
});
}
/// <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);
}
static ISet <SyntaxTree> getMutationsForNode(SyntaxNode node, SyntaxNode rootNode, DataFlow optionalDataFlow = null)
{
ISet <SyntaxTree> toReturn = new HashSet <SyntaxTree>();
BinaryExpressionSyntax binaryExpression = node as BinaryExpressionSyntax;
PostfixUnaryExpressionSyntax postfixUnaryExpression = node as PostfixUnaryExpressionSyntax;
PrefixUnaryExpressionSyntax prefixUnaryExpression = node as PrefixUnaryExpressionSyntax;
BlockSyntax block = node as BlockSyntax;
StatementSyntax statement = node as StatementSyntax;
IdentifierNameSyntax identifierName = node as IdentifierNameSyntax;
if (binaryExpression != null)
{
ISet <SyntaxToken> validMutations = validBinaryOperatorMutations(binaryExpression);
foreach (SyntaxToken mutatedToken in validMutations)
{
SyntaxNode newRoot = rootNode.ReplaceNode(node, binaryExpression.WithOperatorToken(mutatedToken).WithTrailingTrivia(syntaxTrivias));
toReturn.Add(newRoot.SyntaxTree);
}
}
else if (postfixUnaryExpression != null)
{
ISet <SyntaxToken> validMutations = validUnaryOperatorMutations(postfixUnaryExpression);
foreach (SyntaxToken mutatedToken in validMutations)
{
SyntaxNode newRoot = rootNode.ReplaceNode(node, postfixUnaryExpression.WithOperatorToken(mutatedToken).WithTrailingTrivia(syntaxTrivias));
toReturn.Add(newRoot.SyntaxTree);
}
}
else if (prefixUnaryExpression != null)
{
ISet <SyntaxToken> validMutations = validUnaryOperatorMutations(prefixUnaryExpression);
foreach (SyntaxToken mutatedToken in validMutations)
{
SyntaxNode newRoot = rootNode.ReplaceNode(node, prefixUnaryExpression.WithOperatorToken(mutatedToken).WithTrailingTrivia(syntaxTrivias));
toReturn.Add(newRoot.SyntaxTree);
}
}
else if (statement != null && block == null)
{
//replace statements with semicolons
toReturn.Add(rootNode.ReplaceNode(node, SyntaxFactory.EmptyStatement(SyntaxFactory.Token(SyntaxKind.SemicolonToken)).WithTrailingTrivia(syntaxTrivias)).SyntaxTree);
}
else if (identifierName != null && optionalDataFlow != null)
{
//Go through reaching definitions and replace with all other variables available
ISet <SyntaxToken> validMutations = validIdentifierNames(identifierName, optionalDataFlow);
foreach (SyntaxToken mutatedToken in validMutations)
{
SyntaxNode newRoot = rootNode.ReplaceNode(node, identifierName.WithIdentifier(mutatedToken).WithTrailingTrivia(syntaxTrivias));
toReturn.Add(newRoot.SyntaxTree);
}
}
return(toReturn);
}
private ProgramState VisitPostfixIncrement(PostfixUnaryExpressionSyntax unary, ProgramState programState)
{
var symbol = SemanticModel.GetSymbolInfo(unary.Operand).Symbol;
// Do not change the stacked value
var sv = new SymbolicValue();
var newProgramState = SetNonNullConstraintIfValueType(symbol, sv, programState);
return(SetNewSymbolicValueIfTracked(symbol, sv, newProgramState));
}
private async Task<Document> AddNullableComment(Document document, PostfixUnaryExpressionSyntax nullableSuppressExpression, CancellationToken cancellationToken)
{
SyntaxNode root = await document.GetSyntaxRootAsync().ConfigureAwait(false);
SyntaxToken oldOperator = nullableSuppressExpression.OperatorToken;
var newOperator = oldOperator.WithLeadingTrivia(SyntaxFactory.Comment(NullableReferenceTypeAnalyzer.NullableSyntaxMarker.Start))
.WithTrailingTrivia(SyntaxFactory.Comment(NullableReferenceTypeAnalyzer.NullableSyntaxMarker.End));
return document.WithSyntaxRoot(root.ReplaceToken(oldOperator, newOperator));
}
public override async Task RegisterCodeFixesAsync(CodeFixContext context)
{
SyntaxNode root = await context.GetSyntaxRootAsync().ConfigureAwait(false);
if (!TryFindNode(
root,
context.Span,
out ExpressionSyntax expression))
{
return;
}
SyntaxDebug.Assert(expression.IsKind(SyntaxKind.NullLiteralExpression, SyntaxKind.DefaultLiteralExpression, SyntaxKind.DefaultExpression), expression);
if (!expression.IsKind(SyntaxKind.NullLiteralExpression, SyntaxKind.DefaultLiteralExpression, SyntaxKind.DefaultExpression))
{
return;
}
if (expression.IsKind(SyntaxKind.NullLiteralExpression) &&
expression.IsParentKind(SyntaxKind.EqualsValueClause) &&
expression.Parent.IsParentKind(SyntaxKind.Parameter))
{
return;
}
Diagnostic diagnostic = context.Diagnostics[0];
Document document = context.Document;
switch (diagnostic.Id)
{
case CompilerDiagnosticIdentifiers.CS8625_CannotConvertNullLiteralToNonNullableReferenceType:
{
if (!IsEnabled(diagnostic.Id, CodeFixIdentifiers.UseNullForgivingOperator, context.Document, root.SyntaxTree))
{
break;
}
CodeAction codeAction = CodeAction.Create(
"Use null-forgiving operator",
ct =>
{
PostfixUnaryExpressionSyntax newExpression = SuppressNullableWarningExpression(expression.WithoutTrivia())
.WithTriviaFrom(expression);
return(document.ReplaceNodeAsync(expression, newExpression, ct));
},
GetEquivalenceKey(diagnostic));
context.RegisterCodeFix(codeAction, diagnostic);
break;
}
}
}
public static Task <Document> RefactorAsync(
Document document,
AssignmentExpressionSyntax assignment,
SyntaxKind kind,
CancellationToken cancellationToken = default(CancellationToken))
{
PostfixUnaryExpressionSyntax postfixUnary = PostfixUnaryExpression(kind, assignment.Left)
.WithTrailingTrivia(GetTrailingTrivia(assignment))
.WithFormatterAnnotation();
return(document.ReplaceNodeAsync(assignment, postfixUnary, cancellationToken));
}
public override SyntaxNode VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
if (IsPropertyAccess(node.Operand))
{
this.AppendCompileIssue(node, IssueType.Error, IssueId.PropertyAccessIssue);
}
this.Visit(node.Operand);
_output.Write(node.OperatorToken, node.OperatorToken.ValueText);
return(node);
}
private static string GetIdentifierFromPostfixOperand(PostfixUnaryExpressionSyntax expression) =>
GetIdentifierFromIdentifierNameSyntax((IdentifierNameSyntax)expression.Operand);
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.CSharpKind())
{
case SyntaxKind.PostDecrementExpression:
case SyntaxKind.PostIncrementExpression:
return SpecializedCollections.SingletonEnumerable(this.Compilation.GetSpecialType(SpecialType.System_Int32));
}
return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
}
private Method TraversePostfixUnaryExpressions(PostfixUnaryExpressionSyntax pues)
{
Method retMethod = new Method();
if (pues.HasLeadingTrivia)
{
SetOuterComments(retMethod, pues.GetLeadingTrivia().ToFullString());
}
if (pues.HasTrailingTrivia)
{
SetInnerComments(retMethod, pues.GetTrailingTrivia().ToFullString());
}
var vars = from aVar in pues.ChildNodes().OfType<IdentifierNameSyntax>() select aVar;
foreach (IdentifierNameSyntax ins in vars)
{
Variables tempVar = new Variables();
tempVar.Name = ins.Identifier.ValueText;
retMethod.AccessedVariables.Add(tempVar);
}
return retMethod;
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
this.OnNodeVisited(node);
if (!this.traverseRootOnly) base.VisitPostfixUnaryExpression(node);
}
public FlatOperand ResolveExpression(PostfixUnaryExpressionSyntax pues, TypeInfo result_type, FlatOperand into_lvalue, List<FlatStatement> instructions)
{
if (into_lvalue == null)
{
into_lvalue = this.AllocateRegister("");
into_lvalue = into_lvalue.GetLValue(this, instructions);
}
SymbolInfo si = Model.GetSymbolInfo(pues.Operand);
FlatOperand fop_subject;
switch (si.Symbol.Kind)
{
case SymbolKind.Parameter:
{
IParameterSymbol ps = (IParameterSymbol)si.Symbol;
if (ps.RefKind == RefKind.None)
{
FlatOperand op = ResolveExpression(pues.Operand, null, instructions);
instructions.Add(FlatStatement.DUPLICATE(into_lvalue, op));
FlatOperand new_lvalue = op.GetLValue(this,instructions);
switch (pues.CSharpKind())
{
case SyntaxKind.PostIncrementExpression:
instructions.Add(FlatStatement.ADD(new_lvalue, op, FlatOperand.Immediate(FlatValue.Int32(1))));
instructions.Add(FlatStatement.ARRAYSET(FlatOperand.Inputs(), FlatOperand.Immediate(FlatValue.Int32(op.OperandIndex)), new_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType))));
return into_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType));
case SyntaxKind.PostDecrementExpression:
instructions.Add(FlatStatement.SUB(new_lvalue, op, FlatOperand.Immediate(FlatValue.Int32(1))));
instructions.Add(FlatStatement.ARRAYSET(FlatOperand.Inputs(), FlatOperand.Immediate(FlatValue.Int32(op.OperandIndex)), new_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType))));
return into_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType));
}
}
else
{
int numParam = 0;
FlatOperand fop_duplicate = ResolveParameter(pues.Operand, null, out numParam, instructions);
FlatOperand new_lvalue = fop_duplicate.GetLValue(this, instructions);
instructions.Add(FlatStatement.DUPLICATE(into_lvalue, fop_duplicate));
switch (pues.CSharpKind())
{
case SyntaxKind.PostIncrementExpression:
instructions.Add(FlatStatement.ADD(new_lvalue, fop_duplicate, FlatOperand.Immediate(FlatValue.Int32(1))));
instructions.Add(FlatStatement.REREFERENCE(FlatOperand.InputRef(numParam,fop_duplicate.ImmediateValue), fop_duplicate));
return into_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType));
case SyntaxKind.PostDecrementExpression:
instructions.Add(FlatStatement.SUB(new_lvalue, fop_duplicate, FlatOperand.Immediate(FlatValue.Int32(1))));
instructions.Add(FlatStatement.REREFERENCE(FlatOperand.InputRef(numParam, fop_duplicate.ImmediateValue), fop_duplicate));
return into_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType));
}
/*
FlatOperand fop_duplicate = AllocateRegister("local_" + op.ToString());
FlatOperand new_lvalue = fop_duplicate.GetLValue(this, instructions);
instructions.Add(FlatStatement.DEREFERENCE(new_lvalue, op));
instructions.Add(FlatStatement.DUPLICATE(into_lvalue, fop_duplicate));
switch (pues.CSharpKind())
{
case SyntaxKind.PostIncrementExpression:
instructions.Add(FlatStatement.ADD(new_lvalue, fop_duplicate, FlatOperand.Immediate(FlatValue.Int32(1))));
instructions.Add(FlatStatement.REREFERENCE(op, fop_duplicate));
return into_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType));
case SyntaxKind.PostDecrementExpression:
instructions.Add(FlatStatement.SUB(new_lvalue, fop_duplicate, FlatOperand.Immediate(FlatValue.Int32(1))));
instructions.Add(FlatStatement.REREFERENCE(op, fop_duplicate));
return into_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType));
}
* */
}
// reference
/*
if (node.CSharpKind() == SyntaxKind.SimpleAssignmentExpression)
{
FlatOperand fop_right = ResolveExpression(node.Right, into_lvalue, instructions);
instructions.Add(FlatStatement.REREFERENCE(fop_subject, fop_right));
return fop_right;
}
else
{
FlatOperand fop_right = ResolveExpression(node.Right, into_lvalue, instructions);
FlatOperand fop_duplicate = AllocateRegister("local_" + fop_subject.ToString());
FlatOperand lvalue_final = fop_duplicate.GetLValue(this, instructions);
instructions.Add(FlatStatement.DEREFERENCE(lvalue_final, fop_subject));
ResolveBinaryExpression(node.CSharpKind(), fop_duplicate, fop_right, lvalue_final, instructions);
instructions.Add(FlatStatement.REREFERENCE(fop_subject, fop_duplicate));
return fop_subject;
}
*/
}
break;
case SymbolKind.Event:
{
IEventSymbol fs = (IEventSymbol)si.Symbol;
fop_subject = ResolveParentExpression(si, pues.Operand, null, null, instructions);
//FlatOperand fop_type = TypeOf(fop_subject, null, null, instructions);
FlatOperand fop_type = Resolve(si.Symbol.ContainingType, null, instructions);
FlatOperand fop_Field;
ITypeSymbol typeSymbol;
{
typeSymbol = fs.Type;
fop_Field = Resolve(fs, fop_type, null, instructions);
}
FlatOperand fop_currentvalue = this.AllocateRegister("");
FlatOperand fop_currentlvalue = fop_currentvalue.GetLValue(this, instructions);
if (fs.IsStatic)
instructions.Add(FlatStatement.GETSTATICFIELD(fop_currentlvalue, fop_Field));
else
instructions.Add(FlatStatement.GETFIELD(fop_currentlvalue, fop_Field, fop_subject));
instructions.Add(FlatStatement.DUPLICATE(into_lvalue, fop_currentvalue));
switch (pues.CSharpKind())
{
case SyntaxKind.PostIncrementExpression:
instructions.Add(FlatStatement.ADD(fop_currentlvalue, fop_currentvalue, FlatOperand.Immediate(FlatValue.Int32(1))));
break;
case SyntaxKind.PostDecrementExpression:
instructions.Add(FlatStatement.SUB(fop_currentlvalue, fop_currentvalue, FlatOperand.Immediate(FlatValue.Int32(1))));
break;
}
if (fs.IsStatic)
instructions.Add(FlatStatement.SETSTATICFIELD(fop_Field, fop_currentvalue));
else
instructions.Add(FlatStatement.SETFIELD(fop_Field, fop_subject, fop_currentvalue));
return into_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType));
}
break;
case SymbolKind.Field:
{
IFieldSymbol fs = (IFieldSymbol)si.Symbol;
fop_subject = ResolveParentExpression(si, pues.Operand, null, null, instructions);
//FlatOperand fop_type = TypeOf(fop_subject, null, null, instructions);
FlatOperand fop_type = Resolve(si.Symbol.ContainingType, null, instructions);
FlatOperand fop_Field;
ITypeSymbol typeSymbol;
{
typeSymbol = fs.Type;
fop_Field = Resolve(fs, fop_type, null, instructions);
}
FlatOperand fop_currentvalue = this.AllocateRegister("");
FlatOperand fop_currentlvalue = fop_currentvalue.GetLValue(this, instructions);
if (fs.IsStatic)
instructions.Add(FlatStatement.GETSTATICFIELD(fop_currentlvalue, fop_Field));
else
instructions.Add(FlatStatement.GETFIELD(fop_currentlvalue, fop_Field, fop_subject));
instructions.Add(FlatStatement.DUPLICATE(into_lvalue, fop_currentvalue));
switch (pues.CSharpKind())
{
case SyntaxKind.PostIncrementExpression:
instructions.Add(FlatStatement.ADD(fop_currentlvalue, fop_currentvalue, FlatOperand.Immediate(FlatValue.Int32(1))));
break;
case SyntaxKind.PostDecrementExpression:
instructions.Add(FlatStatement.SUB(fop_currentlvalue, fop_currentvalue, FlatOperand.Immediate(FlatValue.Int32(1))));
break;
}
if (fs.IsStatic)
instructions.Add(FlatStatement.SETSTATICFIELD(fop_Field, fop_currentvalue));
else
instructions.Add(FlatStatement.SETFIELD(fop_Field, fop_subject, fop_currentvalue));
return into_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType));
}
break;
case SymbolKind.Property:
{
IPropertySymbol ps = (IPropertySymbol)si.Symbol;
fop_subject = ResolveParentExpression(si, pues.Operand, null, null, instructions);
FlatOperand fop_type;
if (ps.IsStatic)
fop_type = fop_subject;
else
fop_type = TypeOf(fop_subject, null, null, instructions);
FlatOperand fop_property;
ITypeSymbol typeSymbol;
{
// if (ps.IsStatic)
// {
// throw new NotImplementedException("static property postfix unary assignment");
// }
typeSymbol = ps.Type;
fop_property = Resolve(ps, fop_type, null, instructions);
}
FlatOperand fop_currentvalue = this.AllocateRegister("");
FlatOperand fop_currentlvalue = fop_currentvalue.GetLValue(this, instructions);
if (ps.IsStatic)
instructions.Add(FlatStatement.GETSTATICPROPERTY(fop_currentlvalue, fop_property));
else
instructions.Add(FlatStatement.GETPROPERTY(fop_currentlvalue, fop_property, fop_subject));
instructions.Add(FlatStatement.DUPLICATE(into_lvalue, fop_currentvalue));
switch (pues.CSharpKind())
{
case SyntaxKind.PostIncrementExpression:
instructions.Add(FlatStatement.ADD(fop_currentlvalue, fop_currentvalue, FlatOperand.Immediate(FlatValue.Int32(1))));
break;
case SyntaxKind.PostDecrementExpression:
instructions.Add(FlatStatement.SUB(fop_currentlvalue, fop_currentvalue, FlatOperand.Immediate(FlatValue.Int32(1))));
break;
}
if (ps.IsStatic)
instructions.Add(FlatStatement.SETSTATICPROPERTY(fop_property, fop_currentvalue));
else
instructions.Add(FlatStatement.SETPROPERTY(fop_property, fop_subject, fop_currentvalue));
return into_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType));
}
break;
case SymbolKind.Local:
{
FlatOperand op = ResolveExpression(pues.Operand, null, instructions);
instructions.Add(FlatStatement.DUPLICATE(into_lvalue, op));
switch (pues.CSharpKind())
{
case SyntaxKind.PostIncrementExpression:
instructions.Add(FlatStatement.ADD(op.GetLValue(this, instructions), op, FlatOperand.Immediate(FlatValue.Int32(1))));
return into_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType));
case SyntaxKind.PostDecrementExpression:
instructions.Add(FlatStatement.SUB(op.GetLValue(this, instructions), op, FlatOperand.Immediate(FlatValue.Int32(1))));
return into_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType));
}
}
break;
}
throw new NotImplementedException("postfix unary " + pues.CSharpKind().ToString() + " - " + si.Symbol.Kind.ToString());
}
public override SyntaxNode VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
var based = base.VisitPostfixUnaryExpression (node);
switch (node.Kind)
{
case SyntaxKind.PostIncrementExpression:
case SyntaxKind.PostDecrementExpression:
return based.WithTrailingTrivia (based.GetTrailingTrivia().Prepend (GetIdComment()));
default:
return based;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="UnaryExpression"/> class.
/// </summary>
/// <param name="syntaxNode"></param>
public UnaryExpression(PostfixUnaryExpressionSyntax syntaxNode)
: this(syntaxNode, null)
{
}
public override void VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
base.VisitPostfixUnaryExpression(node);
if (node.IsKind(SyntaxKind.PostDecrementExpression) || node.IsKind(SyntaxKind.PostIncrementExpression))
{
var postfixed = node.Operand;
if (postfixed.IsKind(SyntaxKind.IdentifierName))
{
var identifier = (IdentifierNameSyntax)postfixed;
if (identifier.Identifier.Text == _testee.Name)
{
_isAssigned = true;
}
}
}
}
private ExpressionSyntax ParsePostFixExpression(ExpressionSyntax expr)
{
Debug.Assert(expr != null);
while (true)
{
var tk = Current.Kind;
switch (tk)
{
case SyntaxKind.OpenParenToken:
expr = new InvocationExpressionSyntax(expr, ParseParenthesizedArgumentList(false));
break;
case SyntaxKind.OpenBracketToken:
expr = new ElementAccessExpressionSyntax(expr,
Match(SyntaxKind.OpenBracketToken),
ParseExpression(),
Match(SyntaxKind.CloseBracketToken));
break;
case SyntaxKind.PlusPlusToken:
case SyntaxKind.MinusMinusToken:
expr = new PostfixUnaryExpressionSyntax(SyntaxFacts.GetPostfixUnaryExpression(tk), expr, NextToken());
break;
case SyntaxKind.DotToken:
expr = new MemberAccessExpressionSyntax(expr, NextToken(), ParseIdentifier());
break;
default:
return expr;
}
}
}
private BoundExpression ProcessPostfixUnary(PostfixUnaryExpressionSyntax node)
{
var expression = BindExpression(node.Operand);
var operatorKind = SyntaxFacts.GetUnaryOperatorKind(node.Kind);
TypeSymbol expressionType;
switch (operatorKind)
{
case UnaryOperatorKind.LogicalNot:
expressionType = IntrinsicTypes.Bool;
break;
case UnaryOperatorKind.BitwiseNot:
expressionType = IntrinsicTypes.Uint;
break;
case UnaryOperatorKind.Plus:
case UnaryOperatorKind.Minus:
case UnaryOperatorKind.PostIncrement:
case UnaryOperatorKind.PostDecrement:
expressionType = expression.Type;
break;
default:
throw new ArgumentOutOfRangeException();
}
return new BoundUnaryExpression(node, expression, operatorKind, expressionType);
}
public override SyntaxNode VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
if (IsPropertyAccess(node.Operand))
this.AppendCompileIssue(node, IssueType.Error, IssueId.PropertyAccessIssue);
this.Visit(node.Operand);
_output.Write(node.OperatorToken, node.OperatorToken.ValueText);
return node;
}
public virtual void VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
DefaultVisit(node);
}
private static void AddPostfixUnaryExpressionTerms(PostfixUnaryExpressionSyntax postfixUnaryExpression, IList<string> terms, ref ExpressionType expressionType)
{
// ++ and -- are the only postfix operators. Since they always have side
// effects, we never consider this an expression.
expressionType = ExpressionType.Invalid;
var flags = ExpressionType.Invalid;
// Ask our subexpression for terms
AddSubExpressionTerms(postfixUnaryExpression.Operand, terms, ref flags);
// Is our expression a valid term?
AddIfValidTerm(postfixUnaryExpression.Operand, flags, terms);
}
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;
}
public override void VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
base.VisitPostfixUnaryExpression(node);
var op = node.OperatorToken.ValueText;
if (op == "++" || op == "--")
{
op = "post" + op;
}
expression = Expression.MakeUnary(unaryOps[op], expression, null);
}
public static void WritePostfix(OutputWriter writer, PostfixUnaryExpressionSyntax expression)
{
var isProperty = false;
var symbol = TypeProcessor.GetSymbolInfo (expression.Operand);
if (symbol.Symbol is IPropertySymbol)
isProperty = true;
if (isProperty)
{
var symbolName = Core.WriteString(expression.Operand);
switch (expression.OperatorToken.RawKind)
{
case (int) SyntaxKind.MinusMinusToken:
if((symbol.Symbol as IPropertySymbol).IsIndexer)
writer.Write (String.Format("/*{0}--*/((){{auto v={0};auto y=v;{0}=(--y);return v;}})()",symbolName));
else
writer.Write (String.Format("/*{0}--*/((){{auto v={0};auto y=v;{0}(--y);return v;}})()",symbolName));
break;
case (int) SyntaxKind.PlusPlusToken:
if((symbol.Symbol as IPropertySymbol).IsIndexer)
writer.Write (String.Format("/*{0}++*/((){{auto v={0},y={0};{0}=(++y);return v;}})()",symbolName));
else
writer.Write (String.Format("/*{0}++*/((){{auto v={0},y={0};{0}(++y);return v;}})()",symbolName));
break;
default:
Core.Write (writer, expression.Operand);
writer.Write (expression.OperatorToken.Text);
break;
}
}
else
{
// if (expression.Operand is MemberAccessExpressionSyntax)
// {
// var memberAccess = expression.Operand as MemberAccessExpressionSyntax;
// var typeInfo = TypeProcessor.GetSymbolInfo(memberAccess.Name);
// if (typeInfo.Symbol.Kind == SymbolKind.Property)
// {
// switch (expression.OperatorToken.RawKind)
// {
// case (int)SyntaxKind.MinusMinusToken:
// var refactored= SyntaxFactory.BinaryExpression(SyntaxKind.SimpleAssignmentExpression,
// expression.Operand,
// SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression, expression.Operand,
// SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression,SyntaxFactory.Literal(-1)))
// ).NormalizeWhitespace();
// Core.Write(writer,refactored);
// break;
// case (int)SyntaxKind.PlusPlusToken:
// var refactored1 = SyntaxFactory.BinaryExpression(SyntaxKind.SimpleAssignmentExpression,
// expression.Operand,
// SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression, expression.Operand,
// SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(+1)))
// ).NormalizeWhitespace();
// Core.Write(writer, refactored1);
// break;
// default:
// throw new Exception("No support for " + expression.OperatorToken.RawKind + " at " +
// Utility.Descriptor(expression));
// }
// }
// else
// {
// switch (expression.OperatorToken.RawKind)
// {
// case (int)SyntaxKind.MinusMinusToken:
// Core.Write(writer, expression.Operand);
// writer.Write("--");
// break;
// case (int)SyntaxKind.PlusPlusToken:
// Core.Write(writer, expression.Operand);
// writer.Write("++");
// break;
// default:
// throw new Exception("No support for " + expression.OperatorToken.RawKind + " at " +
// Utility.Descriptor(expression));
// }
// }
//
// }
// else
// {
//D's unary operators are a bit different from C# .. i.e. not static
bool hasOpIncrement =false;
bool hasOpDecrement = false;
var typeSymbol = TypeProcessor.GetTypeInfo(expression.Operand).Type;
if (typeSymbol != null)
{
hasOpIncrement = typeSymbol.GetMembers("op_Increment").Any();
hasOpDecrement = typeSymbol.GetMembers("op_Decrement").Any();
}
switch (expression.OperatorToken.RawKind)
{
case (int) SyntaxKind.MinusMinusToken:
if (hasOpDecrement)
{
var texpression = Core.WriteString(expression.Operand);
writer.Write(String.Format("/*{0}--*/({0}={0}.op_Decrement({0}))", texpression));
}
else
{
Core.Write(writer, expression.Operand);
writer.Write("--");
}
break;
case (int) SyntaxKind.PlusPlusToken:
if (hasOpIncrement)
{
var texpression = Core.WriteString(expression.Operand);
writer.Write(String.Format("/*{0}--*/({0}={0}.op_Increment({0}))", texpression));
}
else
{
Core.Write(writer, expression.Operand);
writer.Write("++");
}
break;
default:
throw new Exception ("No support for " + expression.OperatorToken.RawKind + " at " +
Utility.Descriptor (expression));
}
}
// }
}
/// <summary>
///
/// </summary>
/// <param name="node"></param>
public override sealed void VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
base.VisitPostfixUnaryExpression(node);
}
/// <summary>
/// Initializes a new instance of the <see cref="UnaryExpression"/> class.
/// </summary>
/// <param name="syntaxNode"></param>
/// <param name="semanticModel"></param>
public UnaryExpression(PostfixUnaryExpressionSyntax syntaxNode, SemanticModel semanticModel)
: base(syntaxNode, semanticModel)
{
this.IsPrefix = false;
}
public FlatOperand ResolveExpression(PostfixUnaryExpressionSyntax pues, TypeInfo result_type, FlatOperand into_lvalue, List<FlatStatement> instructions)
{
if (into_lvalue == null)
{
into_lvalue = this.AllocateRegister("");
into_lvalue = into_lvalue.GetLValue(this, instructions);
}
SymbolInfo si = Model.GetSymbolInfo(pues.Operand);
FlatOperand fop_subject;
switch (si.Symbol.Kind)
{
/*
case SymbolKind.Field:
{
// need the parent object for the field
fop_subject = ResolveParentExpression(si, pues.Operand, null, instructions);
TypeSymbol typeSymbol;
FieldSymbol ps = (FieldSymbol)si.Symbol;
if (ps.IsStatic)
{
throw new NotImplementedException("static Field assignment");
}
typeSymbol = ps.Type;
int nField;
if (!GetRuntimeFieldNumber(ps, out nField))
{
throw new NotImplementedException("missing field " + ps.ToDisplayString());
}
FlatOperand fop_fieldnum = FlatOperand.LiteralInteger(nField);
FlatOperand fop_currentvalue = this.AllocateRegister("");
FlatOperand fop_currentlvalue = fop_currentvalue.GetLValue(this, instructions);
// DUPLICATE (to return) the current value of the field
// then increment and SETFIELD
instructions.Add(FlatStatement.GETFIELD(fop_currentlvalue, fop_subject, fop_fieldnum));
instructions.Add(FlatStatement.DUPLICATE(into_lvalue, fop_currentvalue));
switch (pues.Kind)
{
case SyntaxKind.PostIncrementExpression:
instructions.Add(FlatStatement.ADD(fop_currentlvalue, fop_currentvalue, FlatOperand.Immediate(FlatValue.Int8(1))));
break;
case SyntaxKind.PostDecrementExpression:
instructions.Add(FlatStatement.SUB(fop_currentlvalue, fop_currentvalue, FlatOperand.Immediate(FlatValue.Int8(1))));
break;
}
instructions.Add(FlatStatement.SETFIELD(fop_subject, fop_fieldnum, fop_currentvalue));
return into_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType));
}
break;*/
case SymbolKind.Field:
{
fop_subject = ResolveParentExpression(si, pues.Operand, null, instructions);
FlatOperand fop_type = TypeOf(fop_subject, null, null, instructions);
FlatOperand fop_Field;
TypeSymbol typeSymbol;
{
FieldSymbol ps = (FieldSymbol)si.Symbol;
if (ps.IsStatic)
{
throw new NotImplementedException("static Field assignment");
}
typeSymbol = ps.Type;
fop_Field = Resolve(ps, fop_type, null, instructions);
}
FlatOperand fop_currentvalue = this.AllocateRegister("");
FlatOperand fop_currentlvalue = fop_currentvalue.GetLValue(this, instructions);
instructions.Add(FlatStatement.GETFIELD(fop_currentlvalue, fop_Field, fop_subject));
instructions.Add(FlatStatement.DUPLICATE(into_lvalue, fop_currentvalue));
switch (pues.Kind)
{
case SyntaxKind.PostIncrementExpression:
instructions.Add(FlatStatement.ADD(fop_currentlvalue, fop_currentvalue, FlatOperand.Immediate(FlatValue.Int32(1))));
break;
case SyntaxKind.PostDecrementExpression:
instructions.Add(FlatStatement.SUB(fop_currentlvalue, fop_currentvalue, FlatOperand.Immediate(FlatValue.Int32(1))));
break;
}
instructions.Add(FlatStatement.SETFIELD(fop_Field, fop_subject, fop_currentvalue));
return into_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType));
}
break;
case SymbolKind.Property:
{
fop_subject = ResolveParentExpression(si, pues.Operand, null, instructions);
FlatOperand fop_type = TypeOf(fop_subject, null, null, instructions);
FlatOperand fop_property;
TypeSymbol typeSymbol;
{
PropertySymbol ps = (PropertySymbol)si.Symbol;
if (ps.IsStatic)
{
throw new NotImplementedException("static property assignment");
}
typeSymbol = ps.Type;
fop_property = Resolve(ps, fop_type, null, instructions);
}
FlatOperand fop_currentvalue = this.AllocateRegister("");
FlatOperand fop_currentlvalue = fop_currentvalue.GetLValue(this, instructions);
instructions.Add(FlatStatement.GETPROPERTY(fop_currentlvalue, fop_property, fop_subject));
instructions.Add(FlatStatement.DUPLICATE(into_lvalue, fop_currentvalue));
switch (pues.Kind)
{
case SyntaxKind.PostIncrementExpression:
instructions.Add(FlatStatement.ADD(fop_currentlvalue, fop_currentvalue, FlatOperand.Immediate(FlatValue.Int32(1))));
break;
case SyntaxKind.PostDecrementExpression:
instructions.Add(FlatStatement.SUB(fop_currentlvalue, fop_currentvalue, FlatOperand.Immediate(FlatValue.Int32(1))));
break;
}
instructions.Add(FlatStatement.SETPROPERTY(fop_property, fop_subject, fop_currentvalue));
return into_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType));
}
break;
case SymbolKind.Local:
{
FlatOperand op = ResolveExpression(pues.Operand, null, instructions);
instructions.Add(FlatStatement.DUPLICATE(into_lvalue, op));
switch (pues.Kind)
{
case SyntaxKind.PostIncrementExpression:
instructions.Add(FlatStatement.ADD(op.GetLValue(this, instructions), op, FlatOperand.Immediate(FlatValue.Int32(1))));
return into_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType));
case SyntaxKind.PostDecrementExpression:
instructions.Add(FlatStatement.SUB(op.GetLValue(this, instructions), op, FlatOperand.Immediate(FlatValue.Int32(1))));
return into_lvalue.AsRValue(FlatValue.FromType(result_type.ConvertedType));
}
}
break;
case SymbolKind.Parameter:
{
}
break;
}
throw new NotImplementedException("postfix unary " + pues.Kind.ToString());
}
public PostfixUnaryExpressionTranslation(PostfixUnaryExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
{
Operand = syntax.Operand.Get<ExpressionTranslation>(this);
}
public static string PostfixUnaryExpression(PostfixUnaryExpressionSyntax expression)
{
return SyntaxNode(expression.Operand) + expression.OperatorToken.Text;
}
private ISymbol GetMutatedSymbol(IDocument document, CancellationToken cancellationToken, PostfixUnaryExpressionSyntax postFixExpression)
{
var model = document.GetSemanticModel(cancellationToken);
var symbolInfo = model.GetSymbolInfo(postFixExpression.Operand, cancellationToken);
return symbolInfo.Symbol;
}
public void VisitPostfixUnaryExpression(PostfixUnaryExpressionSyntax node)
{
if (node == null)
throw new ArgumentNullException("node");
node.Validate();
ExpressionStart(node);
node.Operand.Accept(this);
switch (node.Operator)
{
case PostfixUnaryOperator.MinusMinus: _writer.WriteOperator(PrinterOperator.MinusMinus); break;
case PostfixUnaryOperator.PlusPlus: _writer.WriteOperator(PrinterOperator.PlusPlus); break;
default: throw ThrowHelper.InvalidEnumValue(node.Operator);
}
ExpressionEnd(node);
}
