public override void VisitInvocationExpression(InvocationExpressionSyntax node)
{
var symbol = (IMethodSymbol)SemanticModel.GetSymbolInfo(node).Symbol;
if (symbol != null)
{
Enums.AsyncDetected type = DetectCPUAsynchronousUsages(node,symbol);
Result.StoreDetectedCPUAsyncUsage(type);
// Check whether there are some blocking operations under task, threadpool, and thread!
//if (type == Enums.AsyncDetected.Task || type == Enums.AsyncDetected.Threadpool || type == Enums.AsyncDetected.Thread)
//{
// foreach (var methodCall in node.DescendantNodes().OfType<InvocationExpressionSyntax>())
// {
// var methodCallSymbol = (IMethodSymbol)SemanticModel.GetSymbolInfo(methodCall).Symbol;
// if (methodCallSymbol != null)
// {
// var synctype = ((IMethodSymbol)methodCallSymbol.OriginalDefinition).DetectSynchronousUsages(SemanticModel);
// if (synctype != Utilities.Enums.SyncDetected.None)
// Logs.TempLog.Info("LONGRUNNING {0} {1}{2}--------------------------", methodCallSymbol, Document.FilePath, node.ToLog());
// }
// }
//}
}
base.VisitInvocationExpression(node);
}
public override void VisitInvocationExpression(InvocationExpressionSyntax node)
{
var symbol = (IMethodSymbol)SemanticModel.GetSymbolInfo(node).Symbol;
if (symbol != null)
{
var type = DetectIOAsynchronousUsages(node, symbol);
Result.StoreDetectedIOAsyncUsage(type);
//DetectBlockingOperations(node, symbol);
//if (type == Enums.AsyncDetected.EAP)
// Logs.TempLog2.Info("{0}{1}*****************************************", Document.FilePath, node.FirstAncestorOrSelf<MethodDeclarationSyntax>().ToLog());
if (type == Enums.AsyncDetected.TAP)
//Logs.TempLog3.Info("{0}{1}*****************************************", Document.FilePath, node.FirstAncestorOrSelf<MethodDeclarationSyntax>().ToLog());
Logs.TempLog3.Info("{0}", symbol);
//if (type == Enums.AsyncDetected.APM)
// Logs.TempLog4.Info("{0}{1}*****************************************", Document.FilePath, node.FirstAncestorOrSelf<MethodDeclarationSyntax>().ToLog());
}
base.VisitInvocationExpression(node);
}
public static ArgumentSyntax FindAsyncStateInvocationArgument(InvocationExpressionSyntax apmSyntax, IMethodSymbol apmSymbol)
{
var parameterIndex = FindMethodParameterIndex(apmSymbol, "object", "state");
var callbackArgument = apmSyntax.ArgumentList.Arguments.ElementAt(parameterIndex);
return callbackArgument;
}
private IEnumerable<SignatureHelpItem> GetDelegateInvokeItems(
InvocationExpressionSyntax invocationExpression, SemanticModel semanticModel, ISymbolDisplayService symbolDisplayService, IAnonymousTypeDisplayService anonymousTypeDisplayService,
IDocumentationCommentFormattingService documentationCommentFormattingService, ISymbol within, INamedTypeSymbol delegateType, CancellationToken cancellationToken)
{
var invokeMethod = delegateType.DelegateInvokeMethod;
if (invokeMethod == null)
{
return null;
}
// Events can only be invoked directly from the class they were declared in.
var expressionSymbol = semanticModel.GetSymbolInfo(invocationExpression.Expression, cancellationToken).GetAnySymbol();
if (expressionSymbol.IsKind(SymbolKind.Event) &&
!expressionSymbol.ContainingType.OriginalDefinition.Equals(within.OriginalDefinition))
{
return null;
}
var position = invocationExpression.SpanStart;
var item = CreateItem(
invokeMethod, semanticModel, position,
symbolDisplayService, anonymousTypeDisplayService,
isVariadic: invokeMethod.IsParams(),
documentation: SpecializedCollections.EmptyEnumerable<SymbolDisplayPart>(),
prefixParts: GetDelegateInvokePreambleParts(invokeMethod, semanticModel, position),
separatorParts: GetSeparatorParts(),
suffixParts: GetDelegateInvokePostambleParts(),
parameters: GetDelegateInvokeParameters(invokeMethod, semanticModel, position, documentationCommentFormattingService, cancellationToken));
return SpecializedCollections.SingletonEnumerable(item);
}
/// <summary>
/// Creates a new ExpressionSyntax to replace the defaultIfNull InvocationExpressionSyntax
/// </summary>
public static ExpressionSyntax CreateRelacementNode(InvocationExpressionSyntax defaultIfNullexpression)
{
// We should change from x.DefaultIfNull(y => y.z...) or x.DefaultIfNull(y => y.[..]...)
// into x?.z... x?[..]...
// Get the expression on which DefaultIfNull is invoked, this is the x
var rootExpression = (defaultIfNullexpression.Expression as MemberAccessExpressionSyntax)?.Expression;
// Get the first parameter to DefaultIfNull, this is the Lambda y => y.z...
var lambda = GetLambdaFromFirstArgument(defaultIfNullexpression);
if (lambda == null) return defaultIfNullexpression;
// Get the MemberAccessExpression y.z or ElementAccessExpression y[..] from the lamba body
var accessExpression = GetLeftMostAccessExpression(lambda);
if (accessExpression == null) return defaultIfNullexpression;
// A ConditionalAccessExpression requires a ..BindingExpression instead of the ..AccessExpression
var bindingExpression = ToBindingExpression(accessExpression);
// Replace the AccessExpression from the Labmda body with the BindingExpression this will result in the .z... or [..]... part
var whenNotNullExpression = (ExpressionSyntax)lambda.Body.ReplaceNode(accessExpression, bindingExpression)
.WithTriviaFrom(accessExpression);
// Combine the x and .z... into x?.z...
return SyntaxFactory.ConditionalAccessExpression(
expression: rootExpression,
whenNotNull: whenNotNullExpression).WithTriviaFrom(defaultIfNullexpression);
}
public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node)
{
// Replace the module method name with a qualified one if this is a module ctor
bool nodeChanged = IsInvocationAModuleCtor(node);
ExpressionSyntax nodeExpression = nodeChanged
? ((IdentifierNameSyntax)node.Expression).WithIdentifier(
SyntaxFactory.Identifier("ConfigScript." + ((IdentifierNameSyntax)node.Expression).Identifier.Text)
.WithTriviaFrom(((IdentifierNameSyntax)node.Expression).Identifier))
: node.Expression;
// Get a hash of all the previous @doc and @ctx lambda parameters and don't replace the same
HashSet<string> currentScopeLambdaParameters = new HashSet<string>(
node.Ancestors().OfType<LambdaExpressionSyntax>().SelectMany(
x => x.DescendantNodes().OfType<ParameterSyntax>()).Select(x => x.Identifier.Text));
// Only do the replacement if this is a module ctor or a module fluent method
ArgumentListSyntax argumentList = node.ArgumentList;
if(nodeChanged || IsInvocationAFluentMethod(node))
{
// Replace @doc and @ctx argument expressions with the appropriate lambda expressions, and stop descending if we hit another module ctor
foreach (ArgumentSyntax argument in node.ArgumentList.Arguments)
{
// Don't replace existing lambda expressions
if (!(argument.Expression is LambdaExpressionSyntax))
{
List<IdentifierNameSyntax> identifierNames = argument
.DescendantNodes(x => !(x is InvocationExpressionSyntax) || !IsInvocationAModuleCtorOrFluentMethod((InvocationExpressionSyntax)x))
.OfType<IdentifierNameSyntax>()
.Where(x => x != null && !currentScopeLambdaParameters.Contains(x.Identifier.Text))
.ToList();
IdentifierNameSyntax docReplacementName = identifierNames.FirstOrDefault(x => x.Identifier.Text.StartsWith("@doc"));
IdentifierNameSyntax ctxReplacementName = identifierNames.FirstOrDefault(x => x.Identifier.Text.StartsWith("@ctx"));
if (docReplacementName != null)
{
argumentList = argumentList.ReplaceNode(argument, SyntaxFactory.Argument(
SyntaxFactory.ParenthesizedLambdaExpression(
SyntaxFactory.ParameterList(
new SeparatedSyntaxList<ParameterSyntax>()
.Add(SyntaxFactory.Parameter(SyntaxFactory.Identifier(docReplacementName.Identifier.Text)))
.Add(SyntaxFactory.Parameter(SyntaxFactory.Identifier(ctxReplacementName == null ? "_" : ctxReplacementName.Identifier.Text)))),
argument.Expression))
.WithTriviaFrom(argument));
nodeChanged = true;
}
else if (ctxReplacementName != null)
{
argumentList = argumentList.ReplaceNode(argument, SyntaxFactory.Argument(
SyntaxFactory.SimpleLambdaExpression(
SyntaxFactory.Parameter(SyntaxFactory.Identifier(ctxReplacementName.Identifier.Text)),
argument.Expression))
.WithTriviaFrom(argument));
nodeChanged = true;
}
}
}
}
// Build and return the result node (or just return the original node)
return base.VisitInvocationExpression(nodeChanged ? node.WithExpression(nodeExpression).WithArgumentList(argumentList) : node);
}
public override void VisitInvocationExpression(InvocationExpressionSyntax node)
{
var symbol = (IMethodSymbol)SemanticModel.GetSymbolInfo(node).Symbol;
if (symbol != null)
{
if(symbol.ToString().Contains("System.Threading.Tasks.Task.WaitAll"))
{
var block = node.Ancestors().OfType<BlockSyntax>().First();
if (block.DescendantNodes().OfType<ForEachStatementSyntax>().Any() || block.DescendantNodes().OfType<ForStatementSyntax>().Any())
return;
foreach (var invocation in block.DescendantNodes().OfType<InvocationExpressionSyntax>())
{
var symbol2 = (IMethodSymbol)SemanticModel.GetSymbolInfo(invocation).Symbol;
if (symbol2!=null && symbol2.IsTaskCreationMethod())
{
Logs.TempLog3.Info("{0}{1}--------------------------", Document.FilePath, block.ToLog());
break;
}
}
}
}
base.VisitInvocationExpression(node);
}
private async Task<Document> CreateInterpolatedString(InvocationExpressionSyntax invocation, Document document, CancellationToken cancellationToken)
{
Assert(invocation.ArgumentList != null);
Assert(invocation.ArgumentList.Arguments.Count >= 2);
Assert(invocation.ArgumentList.Arguments[0].Expression.IsKind(SyntaxKind.StringLiteralExpression));
var semanticModel = await document.GetSemanticModelAsync(cancellationToken);
var arguments = invocation.ArgumentList.Arguments;
var text = ((LiteralExpressionSyntax)arguments[0].Expression).Token.ToString();
var builder = ImmutableArray.CreateBuilder<ExpressionSyntax>();
for (int i = 1; i < arguments.Count; i++)
{
builder.Add(CastAndParenthesize(arguments[i].Expression, semanticModel));
}
var expandedArguments = builder.ToImmutable();
var interpolatedString = (InterpolatedStringExpressionSyntax)SyntaxFactory.ParseExpression("$" + text);
var newInterpolatedString = InterpolatedStringRewriter.Visit(interpolatedString, expandedArguments);
var root = await document.GetSyntaxRootAsync(cancellationToken);
var newRoot = root.ReplaceNode(invocation, newInterpolatedString);
return document.WithSyntaxRoot(newRoot);
}
private Task<Document> ConvertToInterpolatedString(Document document, SyntaxNode root, InvocationExpressionSyntax invocation, CancellationToken cancellationToken)
{
string previousString = null;
var parts = new List<InterpolatedStringContentSyntax>(invocation.ArgumentList.Arguments.Count);
for (int i = 0; i < invocation.ArgumentList.Arguments.Count; i++)
{
ArgumentSyntax argument = invocation.ArgumentList.Arguments[i];
var literal = argument.Expression as LiteralExpressionSyntax;
if (literal?.IsKind(SyntaxKind.StringLiteralExpression) ?? false)
{
//strings needs to be collapsed, otherwise VS will insert additional whitespaces
previousString += literal.Token.Text.Substring(1, literal.Token.Text.Length - 2);
}
else
{
if (previousString != null)
{
parts.Add(InterpolatedStringGenerator.TextPart(previousString));
previousString = null;
}
parts.Add(InterpolatedStringGenerator.ExpressionPart(argument.Expression.WithoutLeadingTrivia().WithoutTrailingTrivia()));
}
}
if (previousString != null)
{
parts.Add(InterpolatedStringGenerator.TextPart(previousString));
}
SyntaxNode interpolated = InterpolatedStringGenerator.InterpolatedString(parts);
root = root.ReplaceNode(invocation, interpolated);
return Task.FromResult(document.WithSyntaxRoot(root));
}
public override void VisitInvocationExpression(InvocationExpressionSyntax node)
{
var symbol = (IMethodSymbol)SemanticModel.GetSymbolInfo(node).Symbol;
if (symbol != null)
{
var asynctype = DetectAsynchronousUsages(node, symbol);
Result.StoreDetectedAsyncUsage(asynctype);
Result.WriteDetectedAsyncUsage(asynctype, Document.FilePath, symbol);
Result.WriteDetectedAsyncUsageToTable(asynctype,Document,symbol,node);
//if (asynctype == Enums.AsyncDetected.Task || asynctype == Enums.AsyncDetected.Threadpool || asynctype == Enums.AsyncDetected.Thread)
//{
// foreach (var methodCall in node.DescendantNodes().OfType<InvocationExpressionSyntax>())
// {
// var methodCallSymbol = (MethodSymbol)SemanticModel.GetSymbolInfo(methodCall).Symbol;
// if (methodCallSymbol != null)
// {
// var synctype = ((MethodSymbol)methodCallSymbol.OriginalDefinition).DetectSynchronousUsages(SemanticModel);
// if (synctype != Utilities.Enums.SyncDetected.None)
// Logs.TempLog.Info("LONGRUNNING {0} {1}\r\n{2}\r\n--------------------------", methodCallSymbol, Document.FilePath, node);
// }
// }
//}
}
base.VisitInvocationExpression(node);
}
public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node)
{
return SimplifyExpression(
node,
newNode: base.VisitInvocationExpression(node),
simplifier: SimplifyExtensionMethod);
}
public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node)
{
var memberAccessExpression = node.Expression as MemberAccessExpressionSyntax;
if (memberAccessExpression != null && memberAccessExpression.Name.ToString() == "TransformExpression")
_transform = true;
return base.VisitInvocationExpression(node);
}
static Document PerformAction(Document document, SyntaxNode root, InvocationExpressionSyntax invocationNode)
{
var arg = invocationNode.ArgumentList.Arguments.Select(a => a.Expression).First();
if (!arg.DescendantNodesAndSelf().OfType<BinaryExpressionSyntax>().All(bop => bop.IsKind(SyntaxKind.BitwiseOrExpression)))
return document;
arg = ConvertBitwiseFlagComparisonToHasFlagsCodeRefactoringProvider.MakeFlatExpression(arg, SyntaxKind.BitwiseAndExpression);
if (arg is BinaryExpressionSyntax)
arg = SyntaxFactory.ParenthesizedExpression(arg);
SyntaxNode nodeToReplace = invocationNode;
while (nodeToReplace.Parent is ParenthesizedExpressionSyntax)
nodeToReplace = nodeToReplace.Parent;
bool negateHasFlags = nodeToReplace.Parent != null && nodeToReplace.Parent.IsKind(SyntaxKind.LogicalNotExpression);
if (negateHasFlags)
nodeToReplace = nodeToReplace.Parent;
var expr = SyntaxFactory.BinaryExpression(
negateHasFlags ? SyntaxKind.EqualsExpression : SyntaxKind.NotEqualsExpression,
SyntaxFactory.ParenthesizedExpression(SyntaxFactory.BinaryExpression(SyntaxKind.BitwiseAndExpression, ((MemberAccessExpressionSyntax)invocationNode.Expression).Expression, arg))
.WithAdditionalAnnotations(Formatter.Annotation),
SyntaxFactory.ParseExpression("0")
);
var newRoot = root.ReplaceNode((SyntaxNode)
nodeToReplace,
expr.WithAdditionalAnnotations(Formatter.Annotation)
);
return document.WithSyntaxRoot(newRoot);
}
private void AnalyzeInvocationExpression(InvocationExpressionSyntax node, SemanticModel model, Action<Diagnostic> reportDiagnostic)
{
if (node.Expression.Kind() == SyntaxKind.SimpleMemberAccessExpression)
{
var memberAccess = (MemberAccessExpressionSyntax)node.Expression;
if (memberAccess.Name != null && IsEqualsOrCompare(memberAccess.Name.Identifier.ValueText))
{
var methodSymbol = model.GetSymbolInfo(memberAccess.Name).Symbol as IMethodSymbol;
if (methodSymbol != null && methodSymbol.ContainingType.SpecialType == SpecialType.System_String)
{
Debug.Assert(IsEqualsOrCompare(methodSymbol.Name));
if (!IsAcceptableOverload(methodSymbol, model))
{
// wrong overload
reportDiagnostic(memberAccess.Name.GetLocation().CreateDiagnostic(Rule));
}
else
{
var lastArgument = node.ArgumentList.Arguments.Last();
var lastArgSymbol = model.GetSymbolInfo(lastArgument.Expression).Symbol;
if (lastArgSymbol != null && lastArgSymbol.ContainingType != null &&
lastArgSymbol.ContainingType.Equals(StringComparisonType) &&
!IsOrdinalOrOrdinalIgnoreCase(lastArgument, model))
{
// right overload, wrong value
reportDiagnostic(lastArgument.GetLocation().CreateDiagnostic(Rule));
}
}
}
}
}
}
private static bool HasCheckForNullThatReturns(InvocationExpressionSyntax invocation, SemanticModel semanticModel, ISymbol symbol)
{
var method = invocation.FirstAncestorOfKind(SyntaxKind.MethodDeclaration) as MethodDeclarationSyntax;
if (method != null && method.Body != null)
{
var ifs = method.Body.Statements.OfKind(SyntaxKind.IfStatement);
foreach (IfStatementSyntax @if in ifs)
{
if ([email protected]?.IsKind(SyntaxKind.EqualsExpression) ?? true) continue;
var equals = (BinaryExpressionSyntax)@if.Condition;
if (equals.Left == null || equals.Right == null) continue;
if (@if.GetLocation().SourceSpan.Start > invocation.GetLocation().SourceSpan.Start) return false;
ISymbol identifierSymbol;
if (equals.Right.IsKind(SyntaxKind.NullLiteralExpression) && equals.Left.IsKind(SyntaxKind.IdentifierName))
identifierSymbol = semanticModel.GetSymbolInfo(equals.Left).Symbol;
else if (equals.Left.IsKind(SyntaxKind.NullLiteralExpression) && equals.Right.IsKind(SyntaxKind.IdentifierName))
identifierSymbol = semanticModel.GetSymbolInfo(equals.Right).Symbol;
else continue;
if (!symbol.Equals(identifierSymbol)) continue;
if (@if.Statement == null) continue;
if (@if.Statement.IsKind(SyntaxKind.Block))
{
var ifBlock = (BlockSyntax)@if.Statement;
if (ifBlock.Statements.OfKind(SyntaxKind.ThrowStatement, SyntaxKind.ReturnStatement).Any()) return true;
}
else
{
if (@if.Statement.IsAnyKind(SyntaxKind.ThrowStatement, SyntaxKind.ReturnStatement)) return true;
}
}
}
return false;
}
private static SyntaxNode RemoveCall(SyntaxNode root,
InvocationExpressionSyntax castInvocation, MemberAccessExpressionSyntax memberAccess)
{
return castInvocation != null
? RemoveExtensionMethodCall(root, castInvocation)
: RemoveStaticMemberCall(root, memberAccess);
}
private static bool IsLambdaWithoutBody(InvocationExpressionSyntax invocation)
{
var arg = invocation.ArgumentList?.Arguments.First();
var lambda = arg.Expression as LambdaExpressionSyntax;
if (lambda == null) return false;
return !(lambda.Body is BlockSyntax);
}
/// <summary>
/// Rewrites the statement with a monitor statement.
/// </summary>
/// <param name="node">LocalDeclarationStatementSyntax</param>
/// <returns>StatementSyntax</returns>
private SyntaxNode RewriteStatement(InvocationExpressionSyntax node)
{
var arguments = new List<ArgumentSyntax>();
arguments.Add(node.ArgumentList.Arguments[0]);
string payload = "";
for (int i = 1; i < node.ArgumentList.Arguments.Count; i++)
{
if (i == node.ArgumentList.Arguments.Count - 1)
{
payload += node.ArgumentList.Arguments[i].ToString();
}
else
{
payload += node.ArgumentList.Arguments[i].ToString() + ", ";
}
}
arguments[0] = SyntaxFactory.Argument(SyntaxFactory.ParseExpression(
"new " + arguments[0].ToString() + "(" + payload + ")"));
var rewritten = node.
WithArgumentList(SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(arguments))).
WithExpression((node.Expression as GenericNameSyntax).
WithIdentifier(SyntaxFactory.Identifier("this.Monitor"))).
WithTriviaFrom(node);
return rewritten;
}
private static void CheckIsInstanceOfTypeCallWithTypeArgument(InvocationExpressionSyntax invocation, IMethodSymbol methodSymbol,
SyntaxNodeAnalysisContext context)
{
if (methodSymbol.Name != "IsInstanceOfType" ||
!methodSymbol.ContainingType.Is(KnownType.System_Type) ||
!invocation.HasExactlyNArguments(1))
{
return;
}
var argument = invocation.ArgumentList.Arguments.First().Expression;
var typeInfo = context.SemanticModel.GetTypeInfo(argument).Type;
if (!typeInfo.Is(KnownType.System_Type))
{
return;
}
var invocationInArgument = argument as InvocationExpressionSyntax;
var message = IsGetTypeCall(invocationInArgument, context.SemanticModel)
? MessageIsInstanceOfTypeWithGetType
: MessageIsInstanceOfType;
context.ReportDiagnostic(Diagnostic.Create(Rule, argument.GetLocation(), message));
}
async Task<Document> MakeUppercaseAsync(Document document, InvocationExpressionSyntax invocation,
CancellationToken cancellationToken)
{
var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
var typeSymbol = semanticModel.GetSymbolInfo(invocation.Expression, cancellationToken).Symbol;
var nfluentCheck = semanticModel.Compilation.NFluentCheckType();
if (typeSymbol == null || nfluentCheck == null) return document;
var newMethod = typeSymbol.Name == "AreEqual" ? "IsEqualTo" : "IsNotEqualTo";
var checkThat = CheckThat(nfluentCheck, invocation.ArgumentList.Arguments[1]);
var replacement = InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
checkThat,
IdentifierName(newMethod)),
ArgumentList(SingletonSeparatedList(invocation.ArgumentList.Arguments[0])))
.WithTriviaFrom(invocation);
var syntaxRoot = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var newSyntaxRoot = syntaxRoot.ReplaceNode(invocation, replacement);
var newDocument = document.WithSyntaxRoot(newSyntaxRoot);
var withUsings = await UsingHelpers.AddUsingsAsync(newDocument, replacement, cancellationToken,
nfluentCheck.ContainingNamespace);
return withUsings;
}
private async Task<Document> ChangeToOneLiteral(InvocationExpressionSyntax ex, Document document, CancellationToken cancellationToken)
{
var literal1 = ex.GetLiteralExpression();
if (literal1 == null) return document;
var literal2 = ex.GetLiteralArgument();
if (literal2 == null) return document;
var x = int.Parse(literal1.Token.ValueText);
var y = int.Parse(literal2.Token.ValueText);
var newValue = 0;
switch (ex.GetMemberName())
{
case "Add": newValue = x + y; break;
case "Sub": newValue = x - y; break;
case "Mul": newValue = x * y; break;
case "Div": newValue = x / y; break;
}
var newLiteral = SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(newValue))
.WithLeadingTrivia(ex.GetLeadingTrivia())
.WithTrailingTrivia(ex.GetTrailingTrivia())
;
var oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
var newRoot = oldRoot.ReplaceNode(ex, newLiteral);
return document.WithSyntaxRoot(newRoot);
}
public ExpressionSyntax Replace(InvocationExpressionSyntax invocation)
{
var replacement = string.Format(@"Nake.TaskRegistry.Invoke(""{0}"", {1})",
task.FullName, BuildArgumentString(invocation));
return SyntaxFactory.ParseExpression(replacement)
.WithLeadingTrivia(invocation.GetLeadingTrivia());
}
static SyntaxNode ToStaticMethodInvocation(SemanticModel model, InvocationExpressionSyntax invocation, MemberAccessExpressionSyntax memberAccess, SymbolInfo invocationRR)
{
var newArgumentList = invocation.ArgumentList.Arguments.ToList();
newArgumentList.Insert(0, SyntaxFactory.Argument(memberAccess.Expression.WithoutLeadingTrivia()));
var newTarget = memberAccess.WithExpression(SyntaxFactory.ParseTypeName(invocationRR.Symbol.ContainingType.ToMinimalDisplayString(model, memberAccess.SpanStart)));
return SyntaxFactory.InvocationExpression(newTarget, SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList<ArgumentSyntax>(newArgumentList)));
}
static bool VerifyMethodCalled(InvocationExpressionSyntax methodCalled, SyntaxNodeAnalysisContext nodeContext)
{
if (methodCalled == null)
throw new ArgumentNullException();
var expression = methodCalled.Expression as MemberAccessExpressionSyntax;
var symbol = nodeContext.SemanticModel.GetSymbolInfo(expression).Symbol;
return symbol.ContainingType.SpecialType == SpecialType.System_String && symbol.Name == "ToCharArray";
}
public bool IsPure(InvocationExpressionSyntax methodInvocation)
{
Contract.Requires(methodInvocation != null);
var symbol = _semanticModel.GetSymbolInfo(methodInvocation).Symbol as IMethodSymbol;
return symbol != null && IsPure(symbol);
}
protected override ExpressionSyntax InspectExpression(InvocationExpressionSyntax node, int cancellationTokenPos, IMethodSymbol candidate, bool explicitExtensionMethodCall)
{
var result = base.InspectExpression(node, cancellationTokenPos, candidate, explicitExtensionMethodCall);
this.results.Add(new ValidatorResult { MethodInvocationSyntax = node, ReplacementExpressionSyntax = result, ReplacementMethodSymbol = candidate });
return node;
}
private static SyntaxNode ReplaceInvocation(InvocationExpressionSyntax invocation, ExpressionSyntax newInvocation, SyntaxNode root)
{
if (invocation.Parent.IsKind(SyntaxKind.LogicalNotExpression))
return root.ReplaceNode(invocation.Parent, newInvocation);
var negatedInvocation = SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, newInvocation);
var newRoot = root.ReplaceNode(invocation, negatedInvocation);
return newRoot;
}
static string BuildArgumentString(InvocationExpressionSyntax invocation)
{
var arguments = invocation.ArgumentList.Arguments;
return arguments.Count != 0
? string.Join(", ", arguments.Select(FormatArgument))
: "new Nake.TaskArgument[0]";
}
public static bool TryGetFormattingParameters(
SemanticModel semanticModel,
InvocationExpressionSyntax invocationExpression,
out ExpressionSyntax formatArgument, out IList<ExpressionSyntax> arguments,
Func<IParameterSymbol, ExpressionSyntax, bool> argumentFilter,
CancellationToken cancellationToken = default (CancellationToken))
{
if (semanticModel == null)
throw new ArgumentNullException(nameof(semanticModel));
if (invocationExpression == null)
throw new ArgumentNullException(nameof(invocationExpression));
var symbolInfo = semanticModel.GetSymbolInfo(invocationExpression.Expression, cancellationToken);
if (argumentFilter == null)
argumentFilter = (p, e) => true;
var symbol = symbolInfo.Symbol;
formatArgument = null;
arguments = new List<ExpressionSyntax>();
var method = symbol as IMethodSymbol;
if (method == null || method.Kind != SymbolKind.Method)
return false;
// Serach for method of type: void Name(string format, params object[] args);
IList<IMethodSymbol> methods = method.ContainingType.GetMembers (method.Name).OfType<IMethodSymbol>().ToList();
if (!methods.Any(m => m.Parameters.Length == 2 &&
m.Parameters[0].Type.SpecialType == SpecialType.System_String && parameterNames.Contains(m.Parameters[0].Name) &&
m.Parameters[1].IsParams))
return false;
// TODO: Handle argument -> parameter mapping.
//var argumentToParameterMap = invocationResolveResult.GetArgumentToParameterMap();
//var resolvedParameters = invocationResolveResult.Member.Parameters;
var allArguments = invocationExpression.ArgumentList.Arguments.ToArray();
for (int i = 0; i < allArguments.Length; i++) {
var parameterIndex = i; //argumentToParameterMap[i];
if (parameterIndex < 0 || parameterIndex >= method.Parameters.Length) {
// No valid mapping for this argument, skip it
continue;
}
var parameter = method.Parameters[parameterIndex];
var argument = allArguments[i];
if (i == 0 && parameter.Type.SpecialType == SpecialType.System_String && parameterNames.Contains(parameter.Name)) {
formatArgument = argument.Expression;
} else if (formatArgument != null && parameter.IsParams /*&& !invocationResolveResult.IsExpandedForm*/) {
var ace = argument.Expression as ArrayCreationExpressionSyntax;
if (ace == null || ace.Initializer == null)
return false;
foreach (var element in ace.Initializer.Expressions) {
if (argumentFilter(parameter, element))
arguments.Add(argument.Expression);
}
} else if (formatArgument != null && argumentFilter(parameter, argument.Expression)) {
arguments.Add(argument.Expression);
}
}
return formatArgument != null;
}
public override void VisitInvocationExpression(InvocationExpressionSyntax node)
{
var symbol = (IMethodSymbol)SemanticModel.GetSymbolInfo(node).Symbol;
if (symbol != null)
{
IsAsyncLibraryConstruct(symbol.OriginalDefinition);
if (symbol.IsAPMBeginMethod())
{
Logs.TempLog.Info(SourceFile.FilePath + "\n" + node + "\n" + symbol + "\n"+ node.FirstAncestorOrSelf<MethodDeclarationSyntax>() + "******************\n");
Result.APM++;
}
else if (node.IsEAPMethod())
{
Result.EAP++;
}
else if (symbol.IsTAPMethod())
{
// printing TAP methods: Logs.TempLog.Info(SourceFile.FilePath + "\n" + node + "\n" + symbol + "******************\n");
Result.TAP++;
}
else if (symbol.IsThreadStart())
{
Result.ThreadInit++;
}
else if (symbol.IsThreadPoolQueueUserWorkItem())
{
Result.ThreadPoolQueue++;
}
else if (symbol.IsBackgroundWorkerMethod())
{
Result.BackgroundWorker++;
}
else if (symbol.IsAsyncDelegate())
{
Result.AsyncDelegate++;
}
else if (symbol.IsTaskCreationMethod())
{
Result.TaskInit++;
}
else if (symbol.IsParallelFor())
{
Result.ParallelFor++;
}
else if (symbol.IsParallelForEach())
{
Result.ParallelForEach++;
}
else if (symbol.IsParallelInvoke())
{
Result.ParallelInvoke++;
}
}
base.VisitInvocationExpression(node);
}
private static InvocationExpressionSyntax Merge(
InvocationExpressionSyntax outerMostInvocation,
MemberAccessExpressionSyntax innerMostWhereAccess,
List <ExpressionSyntax> whereArguments,
SemanticModel semanticModel)
{
var firstArgument = whereArguments[0];
string parameterName;
ParameterSyntax firstParameter;
IdentifierNameSyntax firstParameterIdentifier;
ExpressionSyntax filterExpression;
if (firstArgument.IsKind(SyntaxKind.SimpleLambdaExpression))
{
var lambda = (SimpleLambdaExpressionSyntax)firstArgument;
firstParameter = lambda.Parameter;
parameterName = firstParameter.Identifier.Text;
firstParameterIdentifier = SyntaxFactory.IdentifierName(firstParameter.Identifier);
filterExpression = MakeExpressionFromLambdaBody(lambda.Body);
}
else
{
parameterName = NameHelper.GetLambdaParameterName(
outerMostInvocation.SpanStart,
semanticModel);
var parameterIdentifier = SyntaxFactory
.Identifier(parameterName)
.WithAdditionalAnnotations(RenameAnnotation.Create());
firstParameter = SyntaxFactory.Parameter(parameterIdentifier);
firstParameterIdentifier = SyntaxFactory.IdentifierName(parameterIdentifier);
filterExpression = ExtendedSyntaxFactory.MakeInvocation(
firstArgument,
firstParameterIdentifier);
}
for (int i = 1; i < whereArguments.Count; ++i)
{
ExpressionSyntax andOperand;
if (whereArguments[i].IsKind(SyntaxKind.SimpleLambdaExpression))
{
var currentLambda = (SimpleLambdaExpressionSyntax)whereArguments[i];
var currentParameter = currentLambda.Parameter;
var currentParameterName = currentParameter.Identifier.Text;
if (currentParameterName != parameterName)
{
var parameterSymbol = semanticModel.GetDeclaredSymbol(currentParameter);
var substituteRewriter = new SubstituteRewriter(
currentParameterName,
parameterSymbol,
semanticModel,
firstParameterIdentifier);
var newBody = (CSharpSyntaxNode)currentLambda.Body.Accept(substituteRewriter);
andOperand = MakeExpressionFromLambdaBody(newBody);
}
else
{
andOperand = MakeExpressionFromLambdaBody(currentLambda.Body);
}
}
else
{
andOperand = ExtendedSyntaxFactory.MakeInvocation(
whereArguments[i],
firstParameterIdentifier);
}
filterExpression = SyntaxFactory.BinaryExpression(
SyntaxKind.LogicalAndExpression,
filterExpression,
andOperand);
}
var newLambda = SyntaxFactory.SimpleLambdaExpression(
firstParameter,
filterExpression);
var newInvocation = ExtendedSyntaxFactory.MakeInvocation(
innerMostWhereAccess,
newLambda);
return(newInvocation);
}
public override void VisitInvocationExpression(InvocationExpressionSyntax node)
{
Console.WriteLine($"[Walker] Found expression: {node}");
base.VisitInvocationExpression(node);
}
public static SyntaxNode MethodInvocation(string name, MethodBase methodInfo, SyntaxNode instance, List <ArgumentSyntax> argumentList, TypeArgumentListSyntax typeArgumentList)
{
var sepList = SyntaxFactory.SeparatedList(argumentList);
if (methodInfo == null)
{
return(SyntaxFactory.EmptyStatement());
}
var propertyInfos = methodInfo.DeclaringType?.GetProperties();
var isSetAccessor = propertyInfos?.FirstOrDefault(prop => prop.GetSetMethod() == methodInfo);
var isGetAccessor = propertyInfos?.FirstOrDefault(prop => prop.GetGetMethod() == methodInfo);
bool isProperty = isSetAccessor != null || isGetAccessor != null;
var methodName = methodInfo.Name;
if (isProperty)
{
methodName = name.Substring(4);
}
bool isGenericMethod = methodInfo.IsGenericMethod;
ExpressionSyntax finalExpressionSyntax = null;
ExpressionSyntax memberAccessExpression = instance == null?SyntaxFactory.IdentifierName(methodInfo.DeclaringType?.Name) : instance as ExpressionSyntax;
if (!isProperty)
{
if (methodInfo.IsConstructor)
{
finalExpressionSyntax = SyntaxFactory.ObjectCreationExpression(
TypeSystem.BuildTypeSyntax(methodInfo.DeclaringType))
.WithArgumentList(SyntaxFactory.ArgumentList(sepList));
}
else
{
SimpleNameSyntax genericName = isGenericMethod
? (SimpleNameSyntax)SyntaxFactory.GenericName(
SyntaxFactory.Identifier(methodName))
.WithTypeArgumentList(typeArgumentList)
: SyntaxFactory.IdentifierName(methodName);
InvocationExpressionSyntax invocation = SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
memberAccessExpression,
genericName
)
);
finalExpressionSyntax = invocation
.WithArgumentList(SyntaxFactory.ArgumentList(sepList));
}
}
else
{
if (isGetAccessor != null)
{
if (isGetAccessor.GetIndexParameters().Length > 0)
{
finalExpressionSyntax = SyntaxFactory.ElementAccessExpression(
memberAccessExpression,
SyntaxFactory.BracketedArgumentList(sepList));
}
else
{
finalExpressionSyntax = SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
memberAccessExpression,
SyntaxFactory.IdentifierName(methodName));
}
}
else if (isSetAccessor != null)
{
ExpressionSyntax left;
if (isSetAccessor.GetIndexParameters().Length > 0)
{
left = SyntaxFactory.ElementAccessExpression(memberAccessExpression, SyntaxFactory.BracketedArgumentList(
SyntaxFactory.SeparatedList(argumentList.Take(argumentList.Count - 1))
));
}
else
{
left = SyntaxFactory.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
memberAccessExpression,
SyntaxFactory.IdentifierName(methodName));
}
finalExpressionSyntax = SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
left,
argumentList.Last().Expression);
}
}
return(finalExpressionSyntax);
}
ParameterHintingResult HandleInvocationExpression(SemanticModel semanticModel, InvocationExpressionSyntax node, CancellationToken cancellationToken)
{
var info = semanticModel.GetSymbolInfo(node, cancellationToken);
var result = new ParameterHintingResult(node.SpanStart);
var targetTypeInfo = semanticModel.GetTypeInfo(node.Expression);
if (targetTypeInfo.Type != null && targetTypeInfo.Type.TypeKind == TypeKind.Delegate)
{
result.AddData(factory.CreateMethodDataProvider(targetTypeInfo.Type.GetDelegateInvokeMethod()));
return(result);
}
var within = semanticModel.GetEnclosingNamedTypeOrAssembly(node.SpanStart, cancellationToken);
ITypeSymbol type;
string name = null;
bool staticLookup = false;
var ma = node.Expression as MemberAccessExpressionSyntax;
var mb = node.Expression as MemberBindingExpressionSyntax;
if (mb != null)
{
info = semanticModel.GetSymbolInfo(mb, cancellationToken);
type = (info.Symbol ?? info.CandidateSymbols.FirstOrDefault())?.ContainingType;
name = mb.Name.Identifier.ValueText;
}
else if (ma != null)
{
staticLookup = semanticModel.GetSymbolInfo(ma.Expression).Symbol is ITypeSymbol;
type = semanticModel.GetTypeInfo(ma.Expression).Type;
name = info.Symbol?.Name ?? ma.Name.Identifier.ValueText;
}
else
{
type = within as ITypeSymbol;
name = info.Symbol?.Name ?? node.Expression.ToString();
var sym = semanticModel.GetEnclosingSymbol(node.SpanStart, cancellationToken);
staticLookup = sym.IsStatic;
}
var addedMethods = new List <IMethodSymbol> ();
var filterMethod = new HashSet <IMethodSymbol> ();
for (; type != null; type = type.BaseType)
{
foreach (var method in type.GetMembers().OfType <IMethodSymbol> ().Concat(GetExtensionMethods(semanticModel, type, node, cancellationToken)).Where(m => m.Name == name))
{
if (staticLookup && !method.IsStatic)
{
continue;
}
if (method.OverriddenMethod != null)
{
filterMethod.Add(method.OverriddenMethod);
}
if (filterMethod.Contains(method))
{
continue;
}
if (addedMethods.Any(added => SignatureComparer.Instance.HaveSameSignature(method, added, true)))
{
continue;
}
if (method.IsAccessibleWithin(within))
{
if (info.Symbol != null)
{
var smethod = (IMethodSymbol)info.Symbol;
if (smethod != null && smethod.OriginalDefinition == method)
{
continue;
}
}
addedMethods.Add(method);
result.AddData(factory.CreateMethodDataProvider(method));
}
}
}
if (info.Symbol != null && !addedMethods.Contains(info.Symbol))
{
if (!staticLookup || info.Symbol.IsStatic)
{
result.AddData(factory.CreateMethodDataProvider((IMethodSymbol)info.Symbol));
}
}
return(result);
}
protected override SyntaxNode GetInvocationReceiver(InvocationExpressionSyntax invocation)
{
return((invocation.Expression as MemberAccessExpressionSyntax)?.Expression);
}
public static ArgumentSyntax FirstArgument(this InvocationExpressionSyntax node)
{
return node.ArgumentList.Arguments.FirstOrDefault();
}
protected override SyntaxNode GetInvocationExpression(InvocationExpressionSyntax invocation)
{
return(invocation.Expression);
}
public static ExpressionSyntax GetLeftSideExpression(this InvocationExpressionSyntax node)
{
return node.Expression.As<MemberAccessExpressionSyntax>()?.Expression;
}
public static string GetLeftSideIdentifier(this InvocationExpressionSyntax node)
{
return node.Expression.As<MemberAccessExpressionSyntax>()?.Expression.ToString();
}
public static SimpleNameSyntax GetRightSideNameSyntax(this InvocationExpressionSyntax node)
{
return node.Expression.As<MemberAccessExpressionSyntax>()?.Name;
}
private static void CheckForIsAssignableFrom(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax invocation,
MemberAccessExpressionSyntax memberAccess, IMethodSymbol methodSymbol,
ExpressionSyntax argument)
{
if (methodSymbol.Name != "IsAssignableFrom" ||
!TypeExaminationOnSystemType.IsGetTypeCall(argument as InvocationExpressionSyntax, context.SemanticModel))
{
return;
}
if (memberAccess.Expression is TypeOfExpressionSyntax)
{
context.ReportDiagnostic(Diagnostic.Create(rule, invocation.GetLocation(),
ImmutableDictionary <string, string> .Empty
.Add(UseIsOperatorKey, true.ToString())
.Add(ShouldRemoveGetType, true.ToString()),
MessageIsOperator));
}
else
{
context.ReportDiagnostic(Diagnostic.Create(rule, invocation.GetLocation(),
ImmutableDictionary <string, string> .Empty
.Add(UseIsOperatorKey, false.ToString())
.Add(ShouldRemoveGetType, true.ToString()),
MessageIsInstanceOfType));
}
}
public async Task <JObject> Resolve(InvocationExpressionSyntax method, Dictionary <string, JObject> memberAccessValues, CancellationToken token)
{
var methodName = "";
int isTryingLinq = 0;
try
{
JObject rootObject = null;
var expr = method.Expression;
if (expr is MemberAccessExpressionSyntax)
{
var memberAccessExpressionSyntax = expr as MemberAccessExpressionSyntax;
rootObject = await Resolve(memberAccessExpressionSyntax.Expression.ToString(), token);
methodName = memberAccessExpressionSyntax.Name.ToString();
}
else if (expr is IdentifierNameSyntax)
{
if (scopeCache.ObjectFields.TryGetValue("this", out JObject valueRet))
{
rootObject = await GetValueFromObject(valueRet, token);
methodName = expr.ToString();
}
}
if (rootObject != null)
{
DotnetObjectId.TryParse(rootObject?["objectId"]?.Value <string>(), out DotnetObjectId objectId);
var typeIds = await sdbHelper.GetTypeIdFromObject(sessionId, int.Parse(objectId.Value), true, token);
int methodId = await sdbHelper.GetMethodIdByName(sessionId, typeIds[0], methodName, token);
var className = await sdbHelper.GetTypeNameOriginal(sessionId, typeIds[0], token);
if (methodId == 0) //try to search on System.Linq.Enumerable
{
if (linqTypeId == -1)
{
linqTypeId = await sdbHelper.GetTypeByName(sessionId, "System.Linq.Enumerable", token);
}
methodId = await sdbHelper.GetMethodIdByName(sessionId, linqTypeId, methodName, token);
if (methodId != 0)
{
foreach (var typeId in typeIds)
{
var genericTypeArgs = await sdbHelper.GetTypeParamsOrArgsForGenericType(sessionId, typeId, token);
if (genericTypeArgs.Count > 0)
{
isTryingLinq = 1;
methodId = await sdbHelper.MakeGenericMethod(sessionId, methodId, genericTypeArgs, token);
break;
}
}
}
}
if (methodId == 0)
{
var typeName = await sdbHelper.GetTypeName(sessionId, typeIds[0], token);
throw new Exception($"Method '{methodName}' not found in type '{typeName}'");
}
var commandParamsObj = new MemoryStream();
var commandParamsObjWriter = new MonoBinaryWriter(commandParamsObj);
if (isTryingLinq == 0)
{
commandParamsObjWriter.WriteObj(objectId, sdbHelper);
}
if (method.ArgumentList != null)
{
commandParamsObjWriter.Write((int)method.ArgumentList.Arguments.Count + isTryingLinq);
if (isTryingLinq == 1)
{
commandParamsObjWriter.WriteObj(objectId, sdbHelper);
}
foreach (var arg in method.ArgumentList.Arguments)
{
if (arg.Expression is LiteralExpressionSyntax)
{
if (!await commandParamsObjWriter.WriteConst(sessionId, arg.Expression as LiteralExpressionSyntax, sdbHelper, token))
{
return(null);
}
}
if (arg.Expression is IdentifierNameSyntax)
{
var argParm = arg.Expression as IdentifierNameSyntax;
if (!await commandParamsObjWriter.WriteJsonValue(sessionId, memberAccessValues[argParm.Identifier.Text], sdbHelper, token))
{
return(null);
}
}
}
var retMethod = await sdbHelper.InvokeMethod(sessionId, commandParamsObj.ToArray(), methodId, "methodRet", token);
return(await GetValueFromObject(retMethod, token));
}
}
return(null);
}
catch (Exception)
{
throw new Exception($"Unable to evaluate method '{methodName}'");
}
}
public Xor7ExpressionSyntax(InvocationExpressionSyntax syntax)
{
_innerXor7 = syntax;
}
public static Type GetNodeDataType(SyntaxNode node)
{
InvocationExpressionSyntax castedNode = (InvocationExpressionSyntax)node;
return(TypeResolver.GetNodeDataType(castedNode.Expression));
}
private static bool IsCompatibleGetComponent(InvocationExpressionSyntax invocation, SemanticModel model)
{
// We are looking for the exact GetComponent method, not other derivatives, so we do not want to use KnownMethods.IsGetComponentName(nameSyntax)
if (invocation.GetMethodNameSyntax() is not {
Identifier : { Text : nameof(UnityEngine.Component.GetComponent) }
})
public override void VisitInvocationExpression(InvocationExpressionSyntax node)
{
IsComplex = true;
base.VisitInvocationExpression(node);
}
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 static bool TryGetCastInLambda(SyntaxKind asOrIs, IMethodSymbol methodSymbol, InvocationExpressionSyntax invocation, out string type)
{
type = null;
if (!AsIsSyntaxKinds.Contains(asOrIs))
{
return(false);
}
var arguments = GetReducedArguments(methodSymbol, invocation);
if (arguments.Count != 1)
{
return(false);
}
var expression = arguments.First().Expression;
var lambdaBody = GetExpressionFromLambda(expression).RemoveParentheses() as BinaryExpressionSyntax;
var lambdaParameter = GetLambdaParameter(expression);
if (lambdaBody == null ||
lambdaParameter == null ||
!lambdaBody.IsKind(asOrIs))
{
return(false);
}
var castedExpression = lambdaBody.Left.RemoveParentheses();
if (lambdaParameter != castedExpression.ToString())
{
return(false);
}
type = lambdaBody.Right.ToString();
return(true);
}
public override IEnumerable <Instruction> VisitInvocationExpression(InvocationExpressionSyntax node)
{
return(_CreateEnumerable(new Invocation((InvocationExpression)_expressionFactory.Create(node))));
}
private static bool IsFirstExpressionInLambdaIsNullChecking(IMethodSymbol methodSymbol, InvocationExpressionSyntax invocation)
{
var arguments = GetReducedArguments(methodSymbol, invocation);
if (arguments.Count != 1)
{
return(false);
}
var expression = arguments.First().Expression;
var binaryExpression = GetExpressionFromLambda(expression).RemoveParentheses() as BinaryExpressionSyntax;
var lambdaParameter = GetLambdaParameter(expression);
while (binaryExpression != null)
{
if (!binaryExpression.IsKind(SyntaxKind.LogicalAndExpression))
{
return(binaryExpression.IsKind(SyntaxKind.NotEqualsExpression) &&
IsNullChecking(binaryExpression, lambdaParameter));
}
binaryExpression = binaryExpression.Left.RemoveParentheses() as BinaryExpressionSyntax;
}
return(false);
}
private static void CheckForIsInstanceOfType(SyntaxNodeAnalysisContext context, InvocationExpressionSyntax invocation,
MemberAccessExpressionSyntax memberAccess, IMethodSymbol methodSymbol)
{
if (methodSymbol.Name != "IsInstanceOfType")
{
return;
}
if (memberAccess.Expression is TypeOfExpressionSyntax)
{
context.ReportDiagnostic(Diagnostic.Create(rule, invocation.GetLocation(),
ImmutableDictionary <string, string> .Empty
.Add(UseIsOperatorKey, true.ToString())
.Add(ShouldRemoveGetType, false.ToString()),
MessageIsOperator));
}
}
private static bool IsExpressionInLambdaIsCast(IMethodSymbol methodSymbol, InvocationExpressionSyntax invocation, out string typeName)
{
return(TryGetCastInLambda(SyntaxKind.AsExpression, methodSymbol, invocation, out typeName) ||
TryGetCastInLambda(methodSymbol, invocation, out typeName));
}
private static bool CheckForCastSimplification(IMethodSymbol outerMethodSymbol, InvocationExpressionSyntax outerInvocation,
IMethodSymbol innerMethodSymbol, InvocationExpressionSyntax innerInvocation, SyntaxNodeAnalysisContext context)
{
string typeNameInInner;
if (MethodNamesForTypeCheckingWithSelect.Contains(outerMethodSymbol.Name) &&
innerMethodSymbol.Name == SelectMethodName &&
IsFirstExpressionInLambdaIsNullChecking(outerMethodSymbol, outerInvocation) &&
TryGetCastInLambda(SyntaxKind.AsExpression, innerMethodSymbol, innerInvocation, out typeNameInInner))
{
context.ReportDiagnostic(Diagnostic.Create(Rule, GetReportLocation(innerInvocation),
string.Format(MessageUseInstead, $"\"OfType<{typeNameInInner}>()\"")));
return(true);
}
string typeNameInOuter;
if (outerMethodSymbol.Name == SelectMethodName &&
innerMethodSymbol.Name == WhereMethodName &&
IsExpressionInLambdaIsCast(outerMethodSymbol, outerInvocation, out typeNameInOuter) &&
TryGetCastInLambda(SyntaxKind.IsExpression, innerMethodSymbol, innerInvocation, out typeNameInInner) &&
typeNameInOuter == typeNameInInner)
{
context.ReportDiagnostic(Diagnostic.Create(Rule, GetReportLocation(innerInvocation),
string.Format(MessageUseInstead, $"\"OfType<{typeNameInInner}>()\"")));
return(true);
}
return(false);
}
private static List <ArgumentSyntax> GetReducedArguments(IMethodSymbol methodSymbol, InvocationExpressionSyntax invocation)
{
return(methodSymbol.MethodKind == MethodKind.ReducedExtension
? invocation.ArgumentList.Arguments.ToList()
: invocation.ArgumentList.Arguments.Skip(1).ToList());
}
private static SyntaxNode RemoveExtensionMethodCall(SyntaxNode root, InvocationExpressionSyntax invocation)
{
var memberAccess = (MemberAccessExpressionSyntax)invocation.Expression;
return(root.ReplaceNode(invocation, memberAccess.Expression));
}
IEnumerable <IMethodSymbol> GetExtensionMethods(SemanticModel semanticModel, ITypeSymbol typeToExtend, InvocationExpressionSyntax node, CancellationToken cancellationToken)
{
var usedNamespaces = new List <string> ();
foreach (var un in semanticModel.GetUsingNamespacesInScope(node))
{
usedNamespaces.Add(MonoDevelop.Ide.TypeSystem.NR5CompatibiltyExtensions.GetFullName(un));
}
var enclosingNamespaceName = MonoDevelop.Ide.TypeSystem.NR5CompatibiltyExtensions.GetFullName(semanticModel.GetEnclosingNamespace(node.SpanStart, cancellationToken));
var stack = new Stack <INamespaceOrTypeSymbol> ();
stack.Push(semanticModel.Compilation.GlobalNamespace);
while (stack.Count > 0)
{
if (cancellationToken.IsCancellationRequested)
{
break;
}
var current = stack.Pop();
var currentNs = current as INamespaceSymbol;
if (currentNs != null)
{
foreach (var member in currentNs.GetNamespaceMembers())
{
var currentNsName = MonoDevelop.Ide.TypeSystem.NR5CompatibiltyExtensions.GetFullName(member);
if (usedNamespaces.Any(u => u.StartsWith(currentNsName, StringComparison.Ordinal)) ||
enclosingNamespaceName == currentNsName ||
(enclosingNamespaceName.StartsWith(currentNsName, StringComparison.Ordinal) &&
enclosingNamespaceName [currentNsName.Length] == '.'))
{
stack.Push(member);
}
}
foreach (var member in currentNs.GetTypeMembers())
{
stack.Push(member);
}
}
else
{
var type = (INamedTypeSymbol)current;
if (type.IsImplicitClass || type.IsScriptClass)
{
continue;
}
if (type.DeclaredAccessibility != Accessibility.Public)
{
if (type.DeclaredAccessibility != Accessibility.Internal)
{
continue;
}
if (!type.IsAccessibleWithin(semanticModel.Compilation.Assembly))
{
continue;
}
}
if (!type.MightContainExtensionMethods)
{
continue;
}
foreach (var extMethod in type.GetMembers().OfType <IMethodSymbol> ().Where(method => method.IsExtensionMethod))
{
var reducedMethod = extMethod.ReduceExtensionMethod(typeToExtend);
if (reducedMethod != null)
{
yield return(reducedMethod);
}
}
}
}
}
public ServiceDependencyItem(CSharpCompilation compilation, InvocationExpressionSyntax expression)
{
Compilation = compilation;
Expression = expression;
}
private static bool MethodIsNotUsingPredicate(IMethodSymbol methodSymbol, InvocationExpressionSyntax invocation)
{
var arguments = GetReducedArguments(methodSymbol, invocation);
return(!arguments.Any() && MethodNamesWithPredicate.Contains(methodSymbol.Name));
}
public static bool GetClassificationForCommandPublication(ISemanticModel model, InvocationExpressionSyntax syntax, CancellationToken cancellationToken)
{
if (syntax == null)
{
return(false);
}
var memberExpression = syntax.Expression as MemberAccessExpressionSyntax;
if (memberExpression == null)
{
return(false);
}
return(memberExpression.Name.Identifier.ValueText == "Send");
}
public static string GetSymbolName(InvocationExpressionSyntax node, SymbolInfo si, string name, SemanticModel semanticModel)
{
var symbol = si.Symbol;
if (symbol == null && si.CandidateSymbols.Any())
{
symbol = si.CandidateSymbols.First();
}
if (symbol != null && symbol.Kind != SymbolKind.Namespace)
{
//bool preserveMemberChange = !(symbol.Kind == SymbolKind.Method || symbol.Kind == SymbolKind.Property);
int enumMode = -1;
if (symbol.ContainingType != null && symbol.ContainingType.TypeKind == TypeKind.Enum && symbol is IFieldSymbol)
{
string enumAttr = Translator.Bridge_ASSEMBLY + ".EnumAttribute";
enumMode = 7;
foreach (var attr in symbol.ContainingType.GetAttributes())
{
if (attr.AttributeClass != null && attr.AttributeClass.FullyQualifiedName() == enumAttr && attr.ConstructorArguments.Any())
{
enumMode = (int)attr.ConstructorArguments.First().Value;
break;
}
}
}
var nameAttr = SyntaxHelper.GetInheritedAttribute(symbol, Bridge.Translator.Translator.Bridge_ASSEMBLY + ".NameAttribute");
bool isIgnore = symbol.ContainingType != null && SyntaxHelper.IsExternalType(symbol.ContainingType);
name = symbol.Name;
if (nameAttr != null)
{
var value = nameAttr.ConstructorArguments.First().Value;
if (value is string)
{
name = value.ToString();
name = Helpers.ConvertNameTokens(name, symbol.Name);
if (!isIgnore && symbol.IsStatic && Helpers.IsReservedStaticName(name))
{
name = Helpers.ChangeReservedWord(name);
}
return(name);
}
//preserveMemberChange = !(bool)value;
enumMode = -1;
}
if (enumMode > 6)
{
switch (enumMode)
{
case 7:
break;
case 8:
name = name.ToLowerInvariant();
break;
case 9:
name = name.ToUpperInvariant();
break;
}
}
/*else
* {
* name = !preserveMemberChange ? Object.Net.Utilities.StringUtils.ToLowerCamelCase(name) : name;
* }*/
if (!isIgnore && symbol.IsStatic && Helpers.IsReservedStaticName(name))
{
name = Helpers.ChangeReservedWord(name);
}
}
return(name);
}
