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))
{
var descendantTargetNodes = target.DescendantNodesAndSelf();
return(!expr.DescendantNodesAndSelf().Any(
n =>
{
// If n is a simple idenifier, try to find it in target expression as well
if (n.IsKind(SyntaxKind.IdentifierName))
{
return descendantTargetNodes.Any(tn =>
tn.IsKind(SyntaxKind.IdentifierName) && (((IdentifierNameSyntax)tn).Identifier.ValueText == ((IdentifierNameSyntax)n).Identifier.ValueText));
}
// StartsWith() is a very simple solution, but should be enough in usual cases
if (n.IsKind(SyntaxKind.SimpleMemberAccessExpression))
{
return ((MemberAccessExpressionSyntax)target).Expression.ToString().StartsWith(((MemberAccessExpressionSyntax)n).Expression.ToString());
}
return false;
}
));
}
return(false);
}
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);
}
private static bool IsCompileTimeConstantPassword(SyntaxNodeAnalysisContext context, ExpressionSyntax syntax)
{
if (syntax is LiteralExpressionSyntax literal &&
literal.Kind() == SyntaxKind.StringLiteralExpression)
{
var v = context.Compilation.GetSemanticModel(syntax.SyntaxTree).GetConstantValue(literal);
if (!v.HasValue)
{
return(false);
}
return(true);
}
if (syntax is ImplicitArrayCreationExpressionSyntax ||
syntax is ArrayCreationExpressionSyntax || syntax is InitializerExpressionSyntax)
{
if (!syntax.HasInitializer())
{
var rank = syntax.DescendantNodesAndSelf().OfType <ArrayRankSpecifierSyntax>().FirstOrDefault();
if (rank == null)
{
return(false);
}
var firstRank = rank.Sizes.FirstOrDefault();
return(firstRank.IsOrContainsCompileTimeConstantValue <int>(context, out _));
}
return(true);
}
return(false);
}
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.NotEqualsExpression) && binaryExpr.Right.IsKind(SyntaxKind.NullLiteralExpression);
MemberAccessExpressionSyntax memberAccessExpressionSyntax = binaryExpr.Left as MemberAccessExpressionSyntax;
if ((memberAccessExpressionSyntax != null) && (memberAccessExpressionToCheck != null) && (memberAccessExpressionSyntax.ToString() == identifierToCheck.ToString()))
return binaryExpr.IsKind(SyntaxKind.NotEqualsExpression) && binaryExpr.Right.IsKind(SyntaxKind.NullLiteralExpression);
identifierName = binaryExpr.Right as IdentifierNameSyntax;
if ((identifierName != null) && (identifierNameToCheck != null) && (identifierName.Identifier.ValueText == identifierNameToCheck.Identifier.ValueText))
return binaryExpr.IsKind(SyntaxKind.NotEqualsExpression) && binaryExpr.Left.IsKind(SyntaxKind.NullLiteralExpression);
memberAccessExpressionSyntax = binaryExpr.Right as MemberAccessExpressionSyntax;
if ((memberAccessExpressionSyntax != null) && (memberAccessExpressionToCheck != null) && (memberAccessExpressionSyntax.ToString() == identifierToCheck.ToString()))
return binaryExpr.IsKind(SyntaxKind.NotEqualsExpression) && binaryExpr.Left.IsKind(SyntaxKind.NullLiteralExpression);
}
return false;
});
}
bool IsLoopVariable(ExpressionSyntax condition, string name)
{
var identifier = condition as IdentifierNameSyntax;
if ((identifier != null) && (identifier.Identifier.ValueText == name))
{
return(true);
}
foreach (var n in condition.DescendantNodesAndSelf())
{
var binOp = n as BinaryExpressionSyntax;
if (binOp != null && binOp.Left.DescendantNodesAndSelf().OfType <IdentifierNameSyntax> ().Any(i => i.Identifier.ValueText == name))
{
return(true);
}
if (n is PrefixUnaryExpressionSyntax || n is PostfixUnaryExpressionSyntax)
{
if (n.DescendantNodesAndSelf().OfType <IdentifierNameSyntax> ().Any(i => i.Identifier.ValueText == name))
{
return(true);
}
}
}
return(false);
}
private static bool HasDisposableNotLocalIdentifier(ExpressionSyntax expression, SemanticModel semanticModel)
{
return(expression
.DescendantNodesAndSelf()
.OfType <IdentifierNameSyntax>()
.Any(identifier => IsDisposableNotLocalIdentifier(identifier, semanticModel)));
}
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;
}
private static IEnumerable <SyntaxToken> GetIdentifiers(ExpressionSyntax expression)
{
return(expression.RemoveParentheses() is IdentifierNameSyntax identifier?ImmutableArray.Create(identifier.Identifier)
: expression.DescendantNodesAndSelf()
.OfType <AssignmentExpressionSyntax>()
.Select(a => a.Left)
.OfType <IdentifierNameSyntax>()
.Select(i => i.Identifier)
.ToImmutableArray());
}
private static bool MayHaveSideEffects(ExpressionSyntax expression)
{
// Checks to see if the expression being invoked looks side-effect free. If so, changing from executing
// each time in the lambda to only executing it once could have impact on the program.
return(!expression.DescendantNodesAndSelf().All(
n => n is TypeSyntax or
TypeArgumentListSyntax or
MemberAccessExpressionSyntax or
InstanceExpressionSyntax or
LiteralExpressionSyntax));
}
private static bool CompileTimeTooShortLiteralOrArray(SyntaxNodeAnalysisContext context, ExpressionSyntax syntax)
{
if (syntax is LiteralExpressionSyntax literal &&
literal.Kind() == SyntaxKind.NumericLiteralExpression)
{
var v = context.SemanticModel.GetConstantValue(literal);
if (!v.HasValue)
{
return(false);
}
if ((int)v.Value < MinimumSaltSize)
{
return(true);
}
return(false);
}
if (syntax is ImplicitArrayCreationExpressionSyntax ||
syntax is ArrayCreationExpressionSyntax || syntax is InitializerExpressionSyntax)
{
if (!syntax.HasInitializer())
{
var rank = syntax.DescendantNodesAndSelf().OfType <ArrayRankSpecifierSyntax>().FirstOrDefault();
if (rank == null)
{
return(false);
}
var firstRank = rank.Sizes.FirstOrDefault();
if (firstRank.IsOrContainsCompileTimeConstantValue <int>(context, out var rankValue))
{
return(rankValue < MinimumSaltSize);
}
return(false);
}
int count;
if (syntax is ArrayCreationExpressionSyntax arrayCreation)
{
count = arrayCreation.Initializer.Expressions.Count;
}
else if (syntax is ImplicitArrayCreationExpressionSyntax implicitArrayCreation)
{
count = implicitArrayCreation.Initializer.Expressions.Count;
}
else
{
count = ((InitializerExpressionSyntax)syntax).Expressions.Count;
}
return(count < MinimumSaltSize);
}
return(false);
}
private SyntaxToken GetRangeVariable(ExpressionSyntax node)
{
try
{
return(Identifier(
node.DescendantNodesAndSelf().
Select(n => _model.GetSymbolInfo(n).Symbol).
SingleOrDefault(n => n is IRangeVariableSymbol)?.Name));
}
catch (Exception)
{
return(Identifier(_state.SourceIdentifier.ValueText));
}
}
/// <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));
}
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);
}
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);
}
private static bool ContainsPossibleUpdate(StatementSyntax statement, ExpressionSyntax expression,
SemanticModel semanticModel)
{
var checkedSymbols = expression.DescendantNodesAndSelf()
.Select(node => semanticModel.GetSymbolInfo(node).Symbol)
.Where(symbol => symbol != null)
.ToImmutableHashSet();
var statementDescendents = statement.DescendantNodesAndSelf().ToList();
var assignmentExpressions = statementDescendents
.OfType <AssignmentExpressionSyntax>()
.Any(expressionSyntax =>
{
var symbol = semanticModel.GetSymbolInfo(expressionSyntax.Left).Symbol;
return(symbol != null && checkedSymbols.Contains(symbol));
});
if (assignmentExpressions)
{
return(true);
}
var postfixUnaryExpression = statementDescendents
.OfType <PostfixUnaryExpressionSyntax>()
.Any(expressionSyntax =>
{
var symbol = semanticModel.GetSymbolInfo(expressionSyntax.Operand).Symbol;
return(symbol != null && checkedSymbols.Contains(symbol));
});
if (postfixUnaryExpression)
{
return(true);
}
var prefixUnaryExpression = statementDescendents
.OfType <PrefixUnaryExpressionSyntax>()
.Any(expressionSyntax =>
{
var symbol = semanticModel.GetSymbolInfo(expressionSyntax.Operand).Symbol;
return(symbol != null && checkedSymbols.Contains(symbol));
});
return(prefixUnaryExpression);
}
public ImmutableHashSet <FindSymbolResult> FindPropertyOrFieldSymbols(SemanticModel model, ExpressionSyntax expression, CancellationToken token)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
ImmutableHashSet <FindSymbolResult> symbolResults = ImmutableHashSet <FindSymbolResult> .Empty;
ImmutableHashSet <FindSymbolResult> .Builder builder = symbolResults.ToBuilder();
token.ThrowIfCancellationRequested();
EnumerateNodes(ref builder, model, expression.DescendantNodesAndSelf(), token);
return(builder.ToImmutable());
}
private static bool ContainsLocalDefinedInLoopBody(
ExpressionSyntax condition,
TextSpan span,
SemanticModel semanticModel,
CancellationToken cancellationToken)
{
foreach (SyntaxNode node in condition.DescendantNodesAndSelf())
{
if (node.IsKind(SyntaxKind.IdentifierName))
{
ISymbol symbol = semanticModel.GetSymbol((ExpressionSyntax)node, cancellationToken);
if (symbol?.Kind == SymbolKind.Local &&
symbol.GetSyntaxOrDefault(cancellationToken)?.Span.IsContainedIn(span) == true)
{
return(true);
}
}
}
return(false);
}
public static string?ResolveStringConstantExpression(this ExpressionSyntax expression)
{
if (expression is LiteralExpressionSyntax literal && literal.Token.IsKind(SyntaxKind.StringLiteralToken))
{
return(literal.Token.ValueText);
}
var values = new List <string>();
foreach (var node in expression.DescendantNodesAndSelf())
{
switch (node)
{
case BinaryExpressionSyntax binaryExpression:
if (!binaryExpression.IsKind(SyntaxKind.AddExpression))
{
return(null);
}
break;
case LiteralExpressionSyntax literalExpression:
if (!literalExpression.Token.IsKind(SyntaxKind.StringLiteralToken))
{
return(null);
}
values.Add(literalExpression.Token.ValueText);
break;
case ParenthesizedExpressionSyntax _:
break;
default:
return(null);
}
}
return(string.Concat(values));
}
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;
}
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;
}
/// <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);
}
/// <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>()));
}
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;
}
public override SyntaxNode VisitBinaryExpression(BinaryExpressionSyntax node) {
if (node.Kind() == SyntaxKind.EqualsExpression) {
bool wasVariableInside = false;
ExpressionSyntax equalsExpressionRight = node.Right;
IEnumerable<SyntaxNode> list = equalsExpressionRight.DescendantNodesAndSelf();
foreach(SyntaxNode n in list) {
if(n is IdentifierNameSyntax) {
//Console.WriteLine(n.ToString());
wasVariableInside = true;
}
}
if (!wasVariableInside) {
ExpressionSyntax left = node.Left.WithoutTrailingTrivia();
ExpressionSyntax right = node.Right.WithTrailingTrivia(node.GetFirstToken().TrailingTrivia);
SyntaxToken sign = node.OperatorToken;
node = node.ReplaceNode(node, SyntaxFactory.BinaryExpression
(SyntaxKind.EqualsExpression, right, sign, left));
}
} else if(node.Kind() == SyntaxKind.NotEqualsExpression) {
ExpressionSyntax notEqualsExpressionRight = node.Right;
bool wasVariableInside = false;
IEnumerable<SyntaxNode> list = notEqualsExpressionRight.DescendantNodesAndSelf();
foreach (SyntaxNode n in list) {
if (n is IdentifierNameSyntax) {
//Console.WriteLine(n.ToString());
wasVariableInside = true;
}
}
if (!wasVariableInside) {
ExpressionSyntax left = node.Left.WithoutTrailingTrivia();
ExpressionSyntax right = node.Right.WithTrailingTrivia(node.GetFirstToken().TrailingTrivia);
SyntaxToken sign = node.OperatorToken;
node = node.ReplaceNode(node, SyntaxFactory.BinaryExpression
(SyntaxKind.EqualsExpression, right, sign, left));
}
}
return base.VisitBinaryExpression(node);
}
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;
});
}
/// <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>());
}