C# PrefixUnaryExpressionSyntax类代码示例

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