C# ExpressionSyntax.DescendantNodesAndSelf方法代码示例

 internal static bool CheckTarget(ExpressionSyntax target, ExpressionSyntax expr)
 {
     if (target.IsKind(SyntaxKind.IdentifierName))
         return !expr.DescendantNodesAndSelf().OfType<IdentifierNameSyntax>().Any(n => ((IdentifierNameSyntax)target).Identifier.ValueText == n.Identifier.ValueText);
     if (target.IsKind(SyntaxKind.SimpleMemberAccessExpression))
         return !expr.DescendantNodesAndSelf().Any(
                 n =>
                 {
                     // StartsWith() is a very simple solution, but should be enough in usual cases
                     if (n.IsKind(SyntaxKind.IdentifierName))
                         return ((MemberAccessExpressionSyntax)target).Expression.ToString().StartsWith(((IdentifierNameSyntax)n).Identifier.ValueText);
                     if (n.IsKind(SyntaxKind.SimpleMemberAccessExpression))
                         return ((MemberAccessExpressionSyntax)target).Expression.ToString().StartsWith(((MemberAccessExpressionSyntax)n).Expression.ToString());
                     return false;
                 }
             );
     return false;
 }

 static string GetParameterName(SemanticModel model, ExpressionSyntax expr)
 {
     foreach (var node in expr.DescendantNodesAndSelf())
     {
         if (!(node is ExpressionSyntax))
             continue;
         var rr = model.GetSymbolInfo(node).Symbol as IParameterSymbol;
         if (rr != null)
             return rr.Name;
     }
     return null;
 }

 /// <summary>
 /// Returns all identifiers.
 /// </summary>
 /// <param name="expr">Expression</param>
 /// <returns>Identifiers</returns>
 public HashSet<IdentifierNameSyntax> GetIdentifiers(ExpressionSyntax expr)
 {
     return new HashSet<IdentifierNameSyntax>(expr.DescendantNodesAndSelf().
             OfType<IdentifierNameSyntax>());
 }

        bool ConditionContainsNullCheck(ExpressionSyntax condition, ExpressionSyntax identifierToCheck)
        {
            var identifierNameToCheck = identifierToCheck as IdentifierNameSyntax;
            var memberAccessExpressionToCheck = identifierToCheck as MemberAccessExpressionSyntax;

            return condition.DescendantNodesAndSelf().Any(n =>
            {
                var binaryExpr = n as BinaryExpressionSyntax;
                if (binaryExpr != null)
                {

                    IdentifierNameSyntax identifierName = binaryExpr.Left as IdentifierNameSyntax;
                    if ((identifierName != null) && (identifierNameToCheck != null) && (identifierName.Identifier.ValueText == identifierNameToCheck.Identifier.ValueText))
                        return binaryExpr.IsKind(SyntaxKind.IsNotExpression) && binaryExpr.Right.IsKind(SyntaxKind.NothingLiteralExpression);
                    MemberAccessExpressionSyntax memberAccessExpressionSyntax = binaryExpr.Left as MemberAccessExpressionSyntax;
                    if ((memberAccessExpressionSyntax != null) && (memberAccessExpressionToCheck != null) && (memberAccessExpressionSyntax.ToString() == identifierToCheck.ToString()))
                        return binaryExpr.IsKind(SyntaxKind.IsNotExpression) && binaryExpr.Right.IsKind(SyntaxKind.NothingLiteralExpression);

                    identifierName = binaryExpr.Right as IdentifierNameSyntax;
                    if ((identifierName != null) && (identifierNameToCheck != null) && (identifierName.Identifier.ValueText == identifierNameToCheck.Identifier.ValueText))
                        return binaryExpr.IsKind(SyntaxKind.IsNotExpression) && binaryExpr.Left.IsKind(SyntaxKind.NothingLiteralExpression);
                    memberAccessExpressionSyntax = binaryExpr.Right as MemberAccessExpressionSyntax;
                    if ((memberAccessExpressionSyntax != null) && (memberAccessExpressionToCheck != null) && (memberAccessExpressionSyntax.ToString() == identifierToCheck.ToString()))
                        return binaryExpr.IsKind(SyntaxKind.IsNotExpression) && binaryExpr.Left.IsKind(SyntaxKind.NothingLiteralExpression);
                }

                return false;
            });
        }

        private ExpressionSyntax AddImplicitThis(ExpressionSyntax bodyExpression, SemanticModel sm, ITypeSymbol type)
        {
            var candidates =
                (from ident in bodyExpression.DescendantNodesAndSelf().OfType<IdentifierNameSyntax>()
                 where ident.Parent.Kind() != SyntaxKind.SimpleMemberAccessExpression || ((MemberAccessExpressionSyntax)ident.Parent).Expression == ident
                 let symbol = sm.GetSymbolInfo(ident).Symbol
                 where !symbol.IsStatic && (symbol.Kind == SymbolKind.Method || symbol.Kind == SymbolKind.Property || symbol.Kind == SymbolKind.Field)
                 where type.GetInheritedMembers().Contains(symbol)
                 select ident).ToList();

            var result = bodyExpression.ReplaceNodes(candidates, (ident, _) => SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
                SyntaxFactory.ThisExpression(), ident));

            return result;
        }

 internal static bool CheckTarget(ExpressionSyntax target, ExpressionSyntax expr)
 {
     if (target.IsKind(SyntaxKind.IdentifierName))
         return !expr.DescendantNodesAndSelf().OfType<IdentifierNameSyntax>().Any(n => ((IdentifierNameSyntax)target).Identifier.ValueText == n.Identifier.ValueText);
     if (target.IsKind(SyntaxKind.SimpleMemberAccessExpression))
         return !expr.DescendantNodesAndSelf().Any(
                 n =>
                 {
                     if (n.IsKind(SyntaxKind.IdentifierName))
                         return ((MemberAccessExpressionSyntax)target).Expression.ToString() == ((IdentifierNameSyntax)n).Identifier.ValueText;
                     if (n.IsKind(SyntaxKind.SimpleMemberAccessExpression))
                         return ((MemberAccessExpressionSyntax)target).Expression.ToString() == ((MemberAccessExpressionSyntax)n).Expression.ToString();
                     return false;
                 }
             );
     return false;
 }

        /// <summary>
        /// Analyzes the assignment expression and rejects a given declaration if it is unsuitable for implicit typing.
        /// </summary>
        /// <returns>
        /// false, if implicit typing cannot be used.
        /// true, otherwise.
        /// </returns>
        protected override bool AssignmentSupportsStylePreference(
            SyntaxToken identifier,
            TypeSyntax typeName,
            ExpressionSyntax initializer,
            SemanticModel semanticModel,
            OptionSet optionSet,
            CancellationToken cancellationToken)
        {
            var expression = GetInitializerExpression(initializer);

            // var cannot be assigned null
            if (expression.IsKind(SyntaxKind.NullLiteralExpression))
            {
                return false;
            }

            // cannot use implicit typing on method group, anonymous function or on dynamic
            var declaredType = semanticModel.GetTypeInfo(typeName, cancellationToken).Type;
            if (declaredType != null &&
               (declaredType.TypeKind == TypeKind.Delegate || declaredType.TypeKind == TypeKind.Dynamic))
            {
                return false;
            }

            // variables declared using var cannot be used further in the same initialization expression.
            if (initializer.DescendantNodesAndSelf()
                    .Where(n => (n as IdentifierNameSyntax)?.Identifier.ValueText.Equals(identifier.ValueText) == true)
                    .Any(n => semanticModel.GetSymbolInfo(n, cancellationToken).Symbol?.IsKind(SymbolKind.Local) == true))
            {
                return false;
            }

            // Get the conversion that occurred between the expression's type and type implied by the expression's context
            // and filter out implicit conversions. If an implicit conversion (other than identity) exists
            // and if we're replacing the declaration with 'var' we'd be changing the semantics by inferring type of
            // initializer expression and thereby losing the conversion.
            var conversion = semanticModel.GetConversion(expression, cancellationToken);
            if (conversion.Exists && conversion.IsImplicit && !conversion.IsIdentity)
            {
                return false;
            }

            // final check to compare type information on both sides of assignment.
            var initializerType = semanticModel.GetTypeInfo(expression, cancellationToken).Type;
            return declaredType.Equals(initializerType);
        }