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); }