internal static string GetNameOfTheInvokedMethod(InvocationExpressionSyntax invoke)
{
if (invoke == null) return null;
var memberAccess = invoke.ChildNodes()
.OfType<MemberAccessExpressionSyntax>()
.FirstOrDefault();
return GetNameExpressionOfTheInvokedMethod(invoke)?.ToString();
}
internal static SimpleNameSyntax GetNameExpressionOfTheInvokedMethod(InvocationExpressionSyntax invoke)
{
if (invoke == null) return null;
var memberAccess = invoke.ChildNodes()
.OfType<MemberAccessExpressionSyntax>()
.FirstOrDefault();
return memberAccess?.Name;
}
internal static Location GetInvocationLocationWithArguments(this InvocationExpressionSyntax invokeExpression)
{
var memberAccess = invokeExpression?.ChildNodes().OfType <MemberAccessExpressionSyntax>().FirstOrDefault();
var nameSyntax = memberAccess?.Name;
var sourceSpan = nameSyntax.GetLocation().SourceSpan;
var location = Location.Create(invokeExpression.SyntaxTree, new TextSpan(sourceSpan.Start, sourceSpan.Length + invokeExpression.ArgumentList.GetLocation().SourceSpan.Length));
return(location);
}
internal static string GetNameOfTheInvokedMethod(InvocationExpressionSyntax invoke)
{
if (invoke == null)
{
return(null);
}
var memberAccess = invoke.ChildNodes()
.OfType <MemberAccessExpressionSyntax>()
.FirstOrDefault();
return(GetNameExpressionOfTheInvokedMethod(invoke)?.ToString());
}
internal static SimpleNameSyntax GetNameExpressionOfTheInvokedMethod(InvocationExpressionSyntax invoke)
{
if (invoke == null)
{
return(null);
}
var memberAccess = invoke.ChildNodes()
.OfType <MemberAccessExpressionSyntax>()
.FirstOrDefault();
return(memberAccess?.Name);
}
private async Task <Document> RemoveWhereAsync(Document document, InvocationExpressionSyntax whereInvoke, InvocationExpressionSyntax nextMethodInvoke, CancellationToken cancellationToken)
{
var root = await document.GetSyntaxRootAsync(cancellationToken);
var whereMemberAccess = whereInvoke.ChildNodes().OfType <MemberAccessExpressionSyntax>().FirstOrDefault();
var nextMethodMemberAccess = nextMethodInvoke.ChildNodes().OfType <MemberAccessExpressionSyntax>().FirstOrDefault();
var newNextMethodInvoke = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, whereMemberAccess.Expression, nextMethodMemberAccess.Name),
whereInvoke.ArgumentList);
var newRoot = root.ReplaceNode(nextMethodInvoke, newNextMethodInvoke);
var newDocument = document.WithSyntaxRoot(newRoot);
return(newDocument);
}
public override bool VisitInvocationExpression(InvocationExpressionSyntax node)
{
// There seems to be no better way to detect a "nameof" expression
var invocationIdentifier = node.ChildNodes().OfType <IdentifierNameSyntax>().FirstOrDefault();
if ((invocationIdentifier != null) && (invocationIdentifier.Identifier.ValueText == "nameof"))
{
return(false);
}
if (base.VisitInvocationExpression(node))
{
return(true);
}
return(CheckRecursion(node));
}
private bool IsClassAndMethod(InvocationExpressionSyntax node, Type className, string methodName)
{
var memberAccess = ((MemberAccessExpressionSyntax)node.ChildNodes().FirstOrDefault(n => n.IsKind(SyntaxKind.SimpleMemberAccessExpression)));
if (memberAccess != null)
{
var leftIdentifier = memberAccess.Expression;
var rightIdentifier = memberAccess.Name;
if (IsChildType(className, leftIdentifier) && rightIdentifier.TryGetInferredMemberName() == methodName)
{
return(true);
}
}
return(false);
}
private string ParseMethodName(InvocationExpressionSyntax node)
{
var memberAccess = node
.ChildNodes()
.OfType <MemberAccessExpressionSyntax>()
.FirstOrDefault();
if (memberAccess == null)
{
return(string.Empty);
}
var methodName = memberAccess
.ChildNodes()
.OfType <IdentifierNameSyntax>()
.Select(s => s.Identifier.ValueText)
.LastOrDefault();
return(methodName ?? string.Empty);
}
private static SyntaxNode CheckCondition(InvocationExpressionSyntax ies)
{
var argumentList = ies.ChildNodes().FirstOrDefault(node => node.IsKind(SyntaxKind.ArgumentList));
if (argumentList == null)
{
return(null);
}
return(argumentList
.DescendantNodes()
.Where(node => node.IsKind(SyntaxKind.SimpleMemberAccessExpression) && node.TryGetInferredMemberName() == "Select")
.FirstOrDefault(node =>
{
var parent = GetParentSimpleMemberAccessExpression(node);
return !(parent != null &&
parent.IsKind(SyntaxKind.SimpleMemberAccessExpression) &&
parent.TryGetInferredMemberName() == "ToList");
}));
}
private static bool IsTaskCompletedWithWhenAll(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax invocationExpr, string taskVariableName)
{
// We only care about awaited invocations, because an un-awaited Task.WhenAll will be an error.
if (invocationExpr.Parent is not AwaitExpressionSyntax)
{
return(false);
}
IEnumerable <MemberAccessExpressionSyntax>?memberAccessList = invocationExpr.ChildNodes().OfType <MemberAccessExpressionSyntax>();
if (memberAccessList.Count() != 1)
{
return(false);
}
MemberAccessExpressionSyntax?memberAccess = memberAccessList.First();
// Does the invocation have the expected `Task.WhenAll` syntax? This is cheaper to verify before looking up its semantic type.
var correctSyntax =
((IdentifierNameSyntax)memberAccess.Expression).Identifier.ValueText == Types.Task.TypeName &&
((IdentifierNameSyntax)memberAccess.Name).Identifier.ValueText == Types.Task.WhenAll;
if (!correctSyntax)
{
return(false);
}
// Is this `Task.WhenAll` invocation from the System.Threading.Tasks.Task type?
ITypeSymbol?classType = context.SemanticModel.GetTypeInfo(memberAccess.Expression).Type;
var correctType = classType.Name == Types.Task.TypeName && classType.BelongsToNamespace(Types.Task.Namespace);
if (!correctType)
{
return(false);
}
// Is the task variable passed as an argument to `Task.WhenAll`?
return(IsVariablePassedToInvocation(invocationExpr, taskVariableName, byRef: false));
}
private Method TraverseInvocationExpression(InvocationExpressionSyntax ies)
{
//TODO
//get method name and accessed variables
//and attributes and qualifiers
Method retIm = new Method();
if (ies.HasLeadingTrivia)
{
SetOuterComments(retIm, ies.GetLeadingTrivia().ToFullString());
}
if (ies.HasTrailingTrivia)
{
SetInnerComments(retIm, ies.GetTrailingTrivia().ToFullString());
}
//havent tested this with extra stuff like setting the variable equal to the method call
//or with variables in the method call
var methods = from aMethod in ies.ChildNodes().OfType<IdentifierNameSyntax>() select aMethod;
foreach (IdentifierNameSyntax ins in methods)
{
InvokedMethod tempMethod = new InvokedMethod();
tempMethod.Name = ins.Identifier.ValueText;
retIm.InvokedMethods.Add(tempMethod);
}
//var args = from aArg in ies.ArgumentList.Arguments.OfType<ArgumentSyntax>() select aArg;
//foreach (ArgumentSyntax asyn in args)
//{
// Variables tempVar = new Variables();
//}
var args = from aArg in ies.Expression.ChildNodes().OfType<IdentifierNameSyntax>() select aArg;
foreach (IdentifierNameSyntax ins in args)
{
Variables tempVar = new Variables();
tempVar.Name = ins.Identifier.ValueText;
retIm.AccessedVariables.Add(tempVar);
}
retIm.Name = ies.Expression.ToString();
return retIm;
}
private static SimpleNameSyntax GetNameOfTheInvokedMethod(InvocationExpressionSyntax invoke) =>
invoke.ChildNodes().OfType<MemberAccessExpressionSyntax>().FirstOrDefault()?.Name;
public override bool VisitInvocationExpression(InvocationExpressionSyntax node)
{
// There seems to be no better way to detect a "nameof" expression
var invocationIdentifier = node.ChildNodes().OfType<IdentifierNameSyntax>().FirstOrDefault();
if ((invocationIdentifier != null) && (invocationIdentifier.Identifier.ValueText == "nameof"))
return false;
if (base.VisitInvocationExpression(node))
return true;
return CheckRecursion(node);
}
private static SimpleNameSyntax GetNameOfTheInvokedMethod(InvocationExpressionSyntax invoke) => invoke.ChildNodes().OfType <MemberAccessExpressionSyntax>().FirstOrDefault()?.Name;
//public WrapSQLCallsInDebug2(string TargetInvocationExpression, string NewInvocationExpression)
//{
// _targetInvocationExpression = TargetInvocationExpression;
// _newInvocationExpression = NewInvocationExpression;
//}
public override Microsoft.CodeAnalysis.SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node)
{
if (TargetPattern == null)
{
return(node);
}
//Microsoft.CodeAnalysis.SyntaxNode newInvocation = null;
var expression = node.Expression;
//InvocationExpressionSyntax newInvocationExpression = null;
InvocationExpressionSyntax newInvocationExpression = node;
//var newExpression = SyntaxFactory.IdentifierName(_newInvocationExpression);
// Decide if want to use RegEx here.
if (expression.ToString() == TargetPattern)
{
var location = node.GetLocation();
var startLine = location.GetLineSpan().StartLinePosition.Line;
var endLine = location.GetLineSpan().EndLinePosition.Line;
var simpleMemberAccessExpression = node.ChildNodes().First();
var firstIdentifier = simpleMemberAccessExpression.ChildNodes().First();
var lastIdentifer = simpleMemberAccessExpression.ChildNodes().Last();
//Dim dbTicks as Long = Log.Debug2("Execution Start", LOG_CATEGORY)
//dbReader = dbCmd.ExecuteReader()
//Log.Trace(String.Format("Execution End: strSQL:{({0})", strSQL), LOG_CATEGORY, dbTicks)
//LocalDeclarationStatementSyntax declareVariable = GetDeclareString("myString");
LocalDeclarationStatementSyntax logStart = GetLogStartSyntax();
InvocationExpressionSyntax logEnd = GetLogEndSyntax();
List <Microsoft.CodeAnalysis.SyntaxNode> newBeforeNodes = new List <Microsoft.CodeAnalysis.SyntaxNode>();
newBeforeNodes.Add(logStart);
List <Microsoft.CodeAnalysis.SyntaxNode> newAfterNodes = new List <Microsoft.CodeAnalysis.SyntaxNode>();
newAfterNodes.Add(logEnd);
List <SyntaxTrivia> newTrivia = new List <SyntaxTrivia>();
string existingLeadingTrivia = node.GetLeadingTrivia().ToString();
string existingLeadingTriviaFull = node.GetLeadingTrivia().ToFullString();
string existingTrailingTrivia = node.GetTrailingTrivia().ToString();
string existingTrailingTriviaFull = node.GetTrailingTrivia().ToFullString();
// Verify this expression is on line by itself
if (VNCCA.Helpers.VB.IsOnLineByItself(node))
{
string startOfLineWhiteSpace = existingLeadingTrivia.Replace(System.Environment.NewLine, "");
newTrivia.Add(SyntaxFactory.CommentTrivia(existingLeadingTriviaFull));
//newTrivia.Add(SyntaxFactory.CommentTrivia(VNCCA.Helpers.VB.MultiLineComment(_comment, startOfLineWhiteSpace)));
//newTrivia.Add(SyntaxFactory.CommentTrivia("' "));
var newExpression = SyntaxFactory.ParseExpression(string.Format("DAL.Helpers.{0}({1})", lastIdentifer, firstIdentifier));
newInvocationExpression = (InvocationExpressionSyntax)newExpression.WithTriviaFrom(node);
//newInvocationExpression = node.WithLeadingTrivia(newTrivia);
}
else
{
Messages.AppendLine(String.Format("node: >{0}< >{1}< Is NOT OnLineByItself", node.ToString(), node.ToFullString()));
newInvocationExpression = node;
}
//try
//{
// var root = node.SyntaxTree.GetRoot();
// var nodeParent = node.Parent;
// var nodeParentParent = nodeParent.Parent;
// var newSomething = root.InsertNodesAfter(node, newAfterNodes);
//}
//catch (Exception ex)
//{
//}
//try
//{
// //var newSomething2 = node.InsertNodesAfter()
//}
//catch (Exception ex)
//{
//}
//newInvocationExpression = node.WithExpression(newExpression);
//newInvocationExpression = node.InsertNodesBefore(node, newBeforeNodes);
//try
//{
// //newInvocationExpression = node.InsertNodesAfter(node.Parent, newAfterNodes);
// node.R
// newInvocationExpression = node.WithExpression(logEnd);
//}
//catch (Exception ex)
//{
//}
//try
//{
// newBeforeNodes.Add(node);
// newBeforeNodes.Add(logEnd);
// newInvocationExpression = node.ReplaceNode(node.Parent, newBeforeNodes);
// //newInvocationExpression = node.InsertNodesAfter(node, newAfterNodes);
//}
//catch (Exception ex)
//{
//}
//newInvocationExpression = newInvocationExpression.InsertNodesAfter(node, newAfterNodes);
RecordMatchAndContext(node, node.ToString());
//Messages.AppendLine(string.Format("Found: >{0}<\n>{1}<\nLocation: >{2}< \nstart:({3}) end:({4})",
// expression.ToString(),
// node.ToFullString(),
// location.ToString(),
// startLine, endLine));
//PerformedReplacement = true;
}
else
{
newInvocationExpression = node;
}
return(base.VisitInvocationExpression(newInvocationExpression));
}
private static Location AnalyzeInvocationExpressionInCycle(InvocationExpressionSyntax ies, SemanticModel sm)
{
var memberAccessExpressionSyntaxs = ies.ChildNodes().OfType <MemberAccessExpressionSyntax>();
if (memberAccessExpressionSyntaxs.Count() != 1)
{
return(Exit());
}
var simpleMemberAccessExpression = memberAccessExpressionSyntaxs.Single();
var partMembers = simpleMemberAccessExpression.ChildNodes();
if (partMembers.Count() != 2)
{
return(Exit());
}
var right = partMembers.Last();
if (!(right is IdentifierNameSyntax identifier))
{
return(Exit());
}
var rightSymbol = sm.GetSymbolInfo(right);
if (!(rightSymbol.Symbol is IMethodSymbol methodSymbol))
{
return(null);
}
if (!InvocationExpression.Contains(identifier.Identifier.ValueText))
{
return(Exit());
}
var linqMethodSymbol = sm.GetSymbolInfo(right);
var left = partMembers.First();
var leftPartSimpleMemberAccessExpressionSymbol = sm.GetSymbolInfo(left);
if (linqMethodSymbol.Symbol is IMethodSymbol rigthMethodSymbol == false)
{
return(Exit());
}
string leftTypeName = null;
if (leftPartSimpleMemberAccessExpressionSymbol.Symbol is ILocalSymbol localSymbol)
{
return(ReturnIfTypeIsIQueryable(localSymbol.Type));
}
if (leftPartSimpleMemberAccessExpressionSymbol.Symbol is IMethodSymbol leftMethodSymbol)
{
return(ReturnIfTypeIsIQueryable(leftMethodSymbol.ReturnType));
}
return(Exit());
Location Exit() => null;
Location ReturnIfTypeIsIQueryable(ITypeSymbol typeInfo) =>
typeInfo.Name == "IQueryable" ? right.GetLocation() : null;
}
