/// <summary>
/// Checks that the path is empty, this is true for this. and base. calls.
/// </summary>
/// <param name="expression">The <see cref="ExpressionSyntax"/>.</param>
/// <returns>True if the path is empty, this is true for this. and base. calls.</returns>
public static bool IsEmpty(ExpressionSyntax expression)
{
using (var walker = PathWalker.Borrow(expression))
{
return(walker.Tokens.Count == 0);
}
}
#pragma warning restore CA1707 // Identifiers should not contain underscores
#pragma warning restore SA1600 // Elements must be documented
#pragma warning restore CS1591 // Missing XML comment for publicly visible type or member
#pragma warning restore SA1313 // Parameter names must begin with lower-case letter
//// ReSharper restore UnusedParameter.Global
/// <summary>
/// Tries to find C in this.C.P1.P2.
/// </summary>
/// <param name="expression">The <see cref="ExpressionSyntax"/>.</param>
/// <param name="token">The root member.</param>
/// <returns>True if root was found.</returns>
public static bool TryFindRoot(ExpressionSyntax expression, out SyntaxToken token)
{
using (var walker = PathWalker.Borrow(expression))
{
return(walker.TryFirst(out token));
}
}
internal static bool Uses(ExpressionSyntax assigned, ExpressionSyntax returned, SyntaxNodeAnalysisContext context, PooledHashSet <SyntaxNode> visited = null)
{
if (assigned is null ||
returned is null)
{
return(false);
}
using (var assignedPath = PathWalker.Borrow(assigned))
{
var containingType = context.ContainingSymbol.ContainingType;
if (UsedMemberWalker.Uses(returned, assignedPath, Search.TopLevel, containingType, context.SemanticModel, context.CancellationToken))
{
return(true);
}
if (assignedPath.IdentifierNames.TrySingle(out var candidate) &&
containingType.TryFindPropertyRecursive(candidate.Identifier.ValueText, out var property) &&
property.TrySingleDeclaration(context.CancellationToken, out var declaration) &&
declaration.TryGetSetter(out var setter) &&
Property.TrySingleAssignmentInSetter(setter, out var assignment))
{
using (visited = PooledHashSet <SyntaxNode> .BorrowOrIncrementUsage(visited))
{
if (visited.Add(candidate))
{
return(Uses(assignment.Left, returned, context, visited));
}
}
}
}
return(false);
}
/// <summary>
/// Tries to find Baz in this.foo.Bar.Baz.
/// </summary>
/// <param name="expression">The <see cref="ExpressionSyntax"/>.</param>
/// <param name="member">The leaf member.</param>
/// <returns>True if leaf was found.</returns>
public static bool TryFindLast(ExpressionSyntax expression, out IdentifierNameSyntax member)
{
using (var walker = PathWalker.Borrow(expression))
{
return(walker.IdentifierNames.TryLast(out member));
}
}
/// <summary> Compares equality by path. </summary>
/// <param name="x">The first instance.</param>
/// <param name="y">The other instance.</param>
/// <returns>True if the instances are found equal.</returns>
public static bool Equals(ExpressionSyntax?x, ExpressionSyntax?y)
{
if (ReferenceEquals(x, y))
{
return(true);
}
if (x is null ||
y is null)
{
return(false);
}
using var xWalker = PathWalker.Borrow(x);
using var yWalker = PathWalker.Borrow(y);
return(Equals(xWalker, yWalker));
}
public static bool Uses(SyntaxNode scope, PathWalker backing, Search search, ITypeSymbol containingType, SemanticModel semanticModel, CancellationToken cancellationToken)
{
using (var walker = Borrow(scope, search, containingType, semanticModel, cancellationToken))
{
foreach (var used in walker.usedMembers)
{
using (var usedPath = PathWalker.Borrow(used))
{
if (MemberPath.Equals(usedPath, backing))
{
return(true);
}
}
}
}
return(false);
}
internal static bool Equals(ExpressionSyntax x, ExpressionSyntax y)
{
if (ReferenceEquals(x, y))
{
return(true);
}
if (x is null ||
y is null)
{
return(false);
}
using (var xWalker = PathWalker.Borrow(x))
using (var yWalker = PathWalker.Borrow(y))
{
return(Equals(xWalker, yWalker));
}
}
/// <summary>
/// Tries to the single member in the path.
/// </summary>
/// <param name="expression">The <see cref="ExpressionSyntax"/>.</param>
/// <param name="token">The single member.</param>
/// <returns>True if the path was only one member this.C or C for example.</returns>
public static bool TrySingle(ExpressionSyntax expression, out SyntaxToken token)
{
using var walker = PathWalker.Borrow(expression);
return(walker.TrySingle(out token));
}
/// <summary> /// Get a <see cref="PathWalker"/> for <paramref name="expression"/>. /// </summary> /// <param name="expression">The expression.</param> /// <returns>A <see cref="PathWalker"/> for <paramref name="expression"/>.</returns> public static PathWalker Get(ExpressionSyntax expression) => PathWalker.Borrow(expression);
