C# EqualsValueClauseSyntax.DescendantNodesAndSelf方法代码示例

        private static bool EqualsValueClauseNotSuitableForVar(
            SyntaxToken identifier,
            TypeSyntax simpleName,
            EqualsValueClauseSyntax equalsValueClause,
            SemanticModel semanticModel,
            CancellationToken cancellationToken)
        {
            // var cannot be assigned null
            if (equalsValueClause.IsKind(SyntaxKind.NullLiteralExpression))
            {
                return true;
            }

            var type = semanticModel.GetTypeInfo(simpleName, cancellationToken).Type;

            // the variable cannot be initialized to a method group or an anonymous function
            if (type != null &&
                type.TypeKind == TypeKind.Delegate)
            {
                return true;
            }

            var initializerType = semanticModel.GetTypeInfo(equalsValueClause.Value, cancellationToken).Type;

            if (!type.Equals(initializerType))
            {
                return true;
            }

            // The assign expression in the initializer cannot be the same symbol as the i
            var possibleSameLocals = equalsValueClause.DescendantNodesAndSelf().Where(n => n.Kind() == SyntaxKind.IdentifierName && ((IdentifierNameSyntax)n).Identifier.ValueText.Equals(identifier.ValueText));
            var anyUse = possibleSameLocals.Any(n =>
            {
                var symbol = semanticModel.GetSymbolInfo(n, cancellationToken).Symbol;
                if (symbol != null && symbol.Kind == SymbolKind.Local)
                {
                    return true;
                }

                return false;
            });

            if (anyUse)
            {
                return true;
            }

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