public override void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
        {
            if (node.Kind() != SyntaxKind.LogicalNotExpression)
            {
                throw new InvalidPreprocessorExpressionException("Expected logical not expression");
            }

            node.Operand.Accept(this);
        }

 private static void GetExpression(PrefixUnaryExpressionSyntax prefix, out ExpressionSyntax expression, out uint count)
 {
     count = 0;
     var currentUnary = prefix;
     do
     {
         count++;
         expression = currentUnary.Operand;
         currentUnary = currentUnary.Operand as PrefixUnaryExpressionSyntax;
     }
     while (currentUnary != null);
 }

 public override SyntaxNode VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
 {
     switch (node.Kind)
     {
         case SyntaxKind.PreIncrementExpression:
             return Syntax.BinaryExpression(SyntaxKind.AddAssignExpression, node.Operand, Syntax.LiteralExpression(SyntaxKind.NumericLiteralExpression, Syntax.Literal(1)));
         case SyntaxKind.PreDecrementExpression:
             return Syntax.BinaryExpression(SyntaxKind.SubtractAssignExpression, node.Operand, Syntax.LiteralExpression(SyntaxKind.NumericLiteralExpression, Syntax.Literal(1)));
         case SyntaxKind.NegateExpression:
             if (node.Operand.Kind == SyntaxKind.NumericLiteralExpression)
             {
                 dynamic newvalue = -((dynamic)((LiteralExpressionSyntax)node.Operand).Token.Value);
                 return Syntax.LiteralExpression(SyntaxKind.NumericLiteralExpression, Syntax.Literal(newvalue));
             }
             return node;
     }
     throw new NotImplementedException("Unary prefix " + node.Kind.ToString());
 }

 public override SyntaxNode VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
 {
     switch (node.CSharpKind())
     {
         case SyntaxKind.PreIncrementExpression:
             return SyntaxFactory.BinaryExpression(SyntaxKind.AddAssignmentExpression, node.Operand, SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)));
         case SyntaxKind.PreDecrementExpression:
             return SyntaxFactory.BinaryExpression(SyntaxKind.SubtractAssignmentExpression, node.Operand, SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)));
     #if NEGATE_EXPRESSION
             case SyntaxKind.NegateExpression:
             if (node.Operand.CSharpKind() == SyntaxKind.NumericLiteralExpression)
             {
                 dynamic newvalue = -((dynamic)((LiteralExpressionSyntax)node.Operand).Token.Value);
                 return SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(newvalue));
             }
             return node;
     #endif
         case SyntaxKind.LogicalNotExpression:
             return SyntaxFactory.BinaryExpression(SyntaxKind.NotEqualsExpression, node.Operand, SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression));
     }
     throw new NotImplementedException("Unary prefix " + node.CSharpKind().ToString());
 }

 public virtual void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
 {
     DefaultVisit(node);
 }

 private static bool TopLevelUnaryInChain(PrefixUnaryExpressionSyntax unary)
 {
     var parent = unary.Parent as PrefixUnaryExpressionSyntax;
     return parent == null || !SameOperators(parent, unary);
 }

 public PrefixUnaryExpressionTranslation(PrefixUnaryExpressionSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
 {
     Operand = syntax.Operand.Get<ExpressionTranslation>(this);
 }

 /// <summary>
 /// Rewrites the expression with a nondetermnistic choice expression.
 /// </summary>
 /// <param name="node">PrefixUnaryExpressionSyntax</param>
 /// <returns>SyntaxNode</returns>
 private SyntaxNode RewriteExpression(PrefixUnaryExpressionSyntax node)
 {
     var text = "this.Nondet()";
     var rewritten = SyntaxFactory.ParseExpression(text);
     return rewritten;
 }

 public override AwaitExpressionInfo GetAwaitExpressionInfo(PrefixUnaryExpressionSyntax node)
 {
     using (Logger.LogBlock(FunctionId.CSharp_SemanticModel_GetAwaitExpressionInfo, message: this.SyntaxTree.FilePath))
     {
         MemberSemanticModel memberModel = GetMemberModel(node);
         return memberModel == null ? default(AwaitExpressionInfo) : memberModel.GetAwaitExpressionInfo(node);
     }
 }

 public override void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
 {
     base.VisitPrefixUnaryExpression(node);
     if (node.IsKind(SyntaxKind.AddressOfExpression) || node.IsKind(SyntaxKind.PointerIndirectionExpression))  // TODO: Check
         MarkUnsafe();
 }

 public static string PrefixUnaryExpression(PrefixUnaryExpressionSyntax expression)
 {
     return expression.OperatorToken.Text + SyntaxNode(expression.Operand);
 }

        public override SyntaxNode VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
        {
            if (IsPropertyAccess(node.Operand))
                this.AppendCompileIssue(node, IssueType.Error, IssueId.PropertyAccessIssue);

            _output.Write(node, node.OperatorToken.ValueText);
            this.Visit(node.Operand);

            return node;
        }

        protected override SyntaxNode VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
        {
            IdentifierNameSyntax name = node.Operand as IdentifierNameSyntax;
            if (name != null)
            {
                switch (node.Kind)
                {
                    case SyntaxKind.PreIncrementExpression:
                    case SyntaxKind.PreDecrementExpression:
                        return GetLogExpression (name.PlainName, node);
                }
            }

            return base.VisitPrefixUnaryExpression (node);
        }

        public override SyntaxNode VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
        {
            var based = base.VisitPrefixUnaryExpression (node);
            switch (node.Kind)
            {
                case SyntaxKind.PreIncrementExpression:
                case SyntaxKind.PreDecrementExpression:
                    return based.WithTrailingTrivia (based.GetTrailingTrivia().Prepend (GetIdComment()));

                default:
                    return based;
            }
        }

        private static void AddPrefixUnaryExpressionTerms(PrefixUnaryExpressionSyntax prefixUnaryExpression, IList<string> terms, ref ExpressionType expressionType)
        {
            expressionType = ExpressionType.Invalid;
            var flags = ExpressionType.Invalid;

            // Ask our subexpression for terms
            AddSubExpressionTerms(prefixUnaryExpression.Operand, terms, ref flags);

            // Is our expression a valid term?
            AddIfValidTerm(prefixUnaryExpression.Operand, flags, terms);

            if (prefixUnaryExpression.IsKind(SyntaxKind.LogicalNotExpression, SyntaxKind.BitwiseNotExpression, SyntaxKind.UnaryMinusExpression, SyntaxKind.UnaryPlusExpression))
            {
                // We're a valid expression if our subexpression is...
                expressionType = flags & ExpressionType.ValidExpression;
            }
        }

            private IEnumerable<ITypeSymbol> InferTypeInPrefixUnaryExpression(PrefixUnaryExpressionSyntax prefixUnaryExpression, SyntaxToken? previousToken = null)
            {
                // If we have a position, then we must be after the prefix token.
                Contract.ThrowIfTrue(previousToken.HasValue && previousToken.Value != prefixUnaryExpression.OperatorToken);

                switch (prefixUnaryExpression.CSharpKind())
                {
                    case SyntaxKind.AwaitExpression:
                        // await <expression>
                        var types = InferTypes(prefixUnaryExpression);

                        var task = this.Compilation.TaskType();
                        var taskOfT = this.Compilation.TaskOfTType();

                        if (task == null || taskOfT == null)
                        {
                            break;
                        }

                        if (!types.Any())
                        {
                            return SpecializedCollections.SingletonEnumerable(task);
                        }

                        return types.Select(t => t.SpecialType == SpecialType.System_Void ? task : taskOfT.Construct(t));

                    case SyntaxKind.PreDecrementExpression:
                    case SyntaxKind.PreIncrementExpression:
                    case SyntaxKind.UnaryPlusExpression:
                    case SyntaxKind.UnaryMinusExpression:
                    case SyntaxKind.BitwiseNotExpression:
                        // ++, --, +Foo(), -Foo(), ~Foo();
                        return SpecializedCollections.SingletonEnumerable(this.Compilation.GetSpecialType(SpecialType.System_Int32));

                    case SyntaxKind.LogicalNotExpression:
                        // !Foo()
                        return SpecializedCollections.SingletonEnumerable(this.Compilation.GetSpecialType(SpecialType.System_Boolean));
                }

                return SpecializedCollections.EmptyEnumerable<ITypeSymbol>();
            }

 /// <summary>
 /// Initializes a new instance of the <see cref="UnaryExpression"/> class.
 /// </summary>
 /// <param name="syntaxNode"></param>
 public UnaryExpression(PrefixUnaryExpressionSyntax syntaxNode)
     : this(syntaxNode, null)
 {
 }

        public override AwaitExpressionInfo GetAwaitExpressionInfo(PrefixUnaryExpressionSyntax node)
        {
            if (node.Kind != SyntaxKind.AwaitExpression)
            {
                throw new ArgumentException("node.Kind==" + node.Kind);
            }

            BoundAwaitExpression boundAwait = GetUpperBoundNode(node) as BoundAwaitExpression;
            if (boundAwait == null)
            {
                return default(AwaitExpressionInfo);
            }

            return new AwaitExpressionInfo(boundAwait.GetAwaiter, boundAwait.IsCompleted, boundAwait.GetResult, boundAwait.IsDynamic);
        }

 public override void VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
 {
     base.VisitPrefixUnaryExpression(node);
     
     var op = node.OperatorToken.ValueText;
     expression = Expression.MakeUnary(unaryOps[op], expression, null);
 }

 private static string GetIdentifierFromPrefixOperand(PrefixUnaryExpressionSyntax expression) =>
     GetIdentifierFromIdentifierNameSyntax((IdentifierNameSyntax)expression.Operand);