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