private async Task <Document> SwapMethodCalls(Document document, InvocationExpressionSyntax typeDecl, CancellationToken cancellationToken)
{
IEnumerable <SyntaxNode> children = typeDecl.ChildNodes();
Debug.Assert(children.Count() > 0);
MemberAccessExpressionSyntax sliceAccess = children.ElementAt(0) as MemberAccessExpressionSyntax;
IEnumerable <SyntaxNode> grandChildren = sliceAccess.ChildNodes();
Debug.Assert(grandChildren.Count() > 0);
SyntaxNode target = grandChildren.ElementAt(0);
MemberAccessExpressionSyntax parent = typeDecl.Parent as MemberAccessExpressionSyntax;
MemberAccessExpressionSyntax newLocal = parent.ReplaceNode(typeDecl, target);
MemberAccessExpressionSyntax formattedLocal = newLocal.WithAdditionalAnnotations(Formatter.Annotation);
InvocationExpressionSyntax replacement = typeDecl.ReplaceNode(target, formattedLocal).WithAdditionalAnnotations(Formatter.Annotation);
SyntaxNode oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
SyntaxNode newRoot = oldRoot.ReplaceNode(parent, replacement);
// Return document with transformed tree.
return(document.WithSyntaxRoot(newRoot));
}
/// <summary>
/// Visit InvocationExpressions for a Given MethodDeclarationSyntax Node.
/// </summary>
/// <param name="invocationExpressionNode"></param>
/// <returns></returns>
public override void VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
if (!node.Span.Equals(nodeLocation))
{
var identifierNode = node.ChildNodes().OfType <IdentifierNameSyntax>();
foreach (var identifier in identifierNode)
{
var result = _cryslSpecificationModel.Event_Section.Methods.Select(x => x.Crypto_Signature
.Where(y => y.Method_Name.ToString().Equals(identifier.Identifier.Value.ToString())));
foreach (var methods in _cryslSpecificationModel.Event_Section.Methods)
{
// Check if method signature matches with the method signature defined in events section of the Crysl.
var cryptoMethods = methods.Crypto_Signature.Select(y => y).Where(x => x.Method_Name.ToString().Equals(identifier.Identifier.Value.ToString()));
if (cryptoMethods.Count() > 0)
{
if (_context.SemanticModel.GetSymbolInfo(identifier).Symbol.Kind.Equals(SymbolKind.Method))
{
var identifierSymbolInfo = (IMethodSymbol)_context.SemanticModel.GetSymbolInfo(identifier).Symbol;
// Check for valid event only if Identifier is of Spec type in Crysl.
if (identifierSymbolInfo.ReturnType.ToString().Equals(_cryslSpecificationModel.Spec_Section.Class_Name))
{
List <MethodSignatureModel> methodSignatureModelsList = new List <MethodSignatureModel>();
foreach (var method in cryptoMethods)
{
ICommonUtilities commonUtilities = serviceProvider.GetService <ICommonUtilities>();
bool isValidEvent = commonUtilities.IsMethodInEvents(method, identifierSymbolInfo, _cryslSpecificationModel.Object_Section.Objects_Declaration);
if (isValidEvent)
{
MethodSignatureModel methodSignatureModel = new MethodSignatureModel
{
MethodName = identifierSymbolInfo.Name,
Parameters = method.Argument_types
};
methodSignatureModelsList.Add(methodSignatureModel);
if (!methodSignatureDict.ContainsKey(method.Event_Var_Name))
{
methodSignatureDict.Add(method.Event_Var_Name, methodSignatureModelsList);
}
else
{
methodSignatureDict[method.Event_Var_Name] = methodSignatureModelsList;
}
/*methodSignatureList.Add(method.Event_Var_Name, new MethodSignatureModel
* {
* MethodName = identifierSymbolInfo.Name,
* Parameters = method.Argument_types
* });*/
}
}
}
}
}
}
}
}
}
public static Domain.Type GetMemberType(this MemberAccessExpressionSyntax member, SemanticModel semanticModel)
{
var node = member.ChildNodes().First();
if (node is IdentifierNameSyntax name)
{
return(semanticModel.GetTypeInfo(name).Type.ToInternalType());
}
throw new NotImplementedException();
}
internal static bool TryGetTypeArgumentIdentifier(MemberAccessExpressionSyntax expression, out SyntaxNode identifierNode)
{
var genericName = expression.ChildNodes().FirstOrDefault(x => x.IsKind(SyntaxKind.GenericName));
if (genericName != null)
{
return(TryGetTypeArgumentIdentifier((GenericNameSyntax)genericName, out identifierNode));
}
identifierNode = null;
return(false);
}
private static SyntaxToken FindSelectToken(MemberAccessExpressionSyntax expression)
{
return(expression
.ChildNodes()
.Where(n => n.IsKind(SyntaxKind.IdentifierName))
.Select(n => n
.ChildTokens()
.FirstOrDefault(t =>
t.IsKind(SyntaxKind.IdentifierToken) && t.Text == "Select"))
.Where(t => t != default)
.FirstOrDefault());
}
public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
var thisNode = node.ChildNodes().FirstOrDefault() as ThisExpressionSyntax;
var nameNode = node.ChildNodes().LastOrDefault() as IdentifierNameSyntax;
if (thisNode == null || nameNode == null)
{
return(base.VisitMemberAccessExpression(node));
}
// Check for field:
var symbolInfo = _semanticModel.GetSymbolInfo(nameNode);
var fieldSymbol = symbolInfo.Symbol as IFieldSymbol;
if (fieldSymbol != null)
{
// Checking for naming ambiguities:
var symbols = _semanticModel.LookupSymbols(node.SpanStart)
.Where(s => new[]
{
SymbolKind.Local,
SymbolKind.Parameter,
SymbolKind.Event,
SymbolKind.Property
}.Any(k => k == s.Kind));
if (symbols.Any(s => s.Name.Equals(nameNode.Identifier.ValueText)))
{
// Removing the "this" qualifier may cause name resolving ambiguities.
// Not removing the "this" qualifier:
return(base.VisitMemberAccessExpression(node));
}
}
// Not field or field be no ambiguities so we are free to remove the "this" qualifier:
// Change memberaccess node to be a simple identified node, but keep the trivia:
return(nameNode.WithLeadingTrivia(thisNode.GetLeadingTrivia()));
}
private static ICollection <TypeSyntax> FindTypeArguments(MemberAccessExpressionSyntax memberAccessExpressionSyntax)
{
var collection = new Collection <TypeSyntax>();
foreach (var genericName in memberAccessExpressionSyntax.ChildNodes().OfType <GenericNameSyntax>())
{
foreach (TypeSyntax item in genericName.TypeArgumentList.Arguments.Where(arg => arg.IsKind(SyntaxKind.IdentifierName)))
{
collection.Add(item);
}
}
return(collection);
}
private bool TryGetTypeArgumentList(MemberAccessExpressionSyntax expression, out SyntaxNode typeArgumentList)
{
var genericNameEnumerable = expression.ChildNodes().Where(x => x.IsKind(SyntaxKind.GenericName));
if (genericNameEnumerable.Any())
{
typeArgumentList = genericNameEnumerable.First().ChildNodes().Where(x => x.IsKind(SyntaxKind.TypeArgumentList)).First();
return(true);
}
typeArgumentList = null;
return(false);
}
private static void AnalyzeNode(SyntaxNodeAnalysisContext context)
{
var nodes = context.Node.ChildNodes();
MemberAccessExpressionSyntax access = null;
foreach (var node in nodes)
{
if (node is MemberAccessExpressionSyntax)
{
access = node as MemberAccessExpressionSyntax;
break;
}
}
if (access == null)
{
return;
}
nodes = access.ChildNodes();
IdentifierNameSyntax identifier = null;
foreach (var node in nodes)
{
if (node is IdentifierNameSyntax)
{
// the last one
identifier = node as IdentifierNameSyntax;
}
}
var symbol = context.SemanticModel.GetSymbolInfo(identifier);
var fieldSymbol = (IFieldSymbol)symbol.Symbol;
var attributes = fieldSymbol.GetAttributes();
foreach (var attribute in attributes)
{
if (attribute.AttributeClass.Name == "DoNotCopyAttribute")
{
var diagnostic = Diagnostic.Create(_rule, context.Node.GetLocation());
context.ReportDiagnostic(diagnostic);
}
}
}
internal static bool TryGetTypeArgumentNode(MemberAccessExpressionSyntax expression, out SyntaxNode identifierNode)
{
var genericName = expression.ChildNodes().Where(x => x.IsKind(SyntaxKind.GenericName)).FirstOrDefault();
if (genericName != null)
{
//GenericName will always have a TypeArgumentList
var typeArgumentList = genericName.ChildNodes().Where(x => x.IsKind(SyntaxKind.TypeArgumentList)).First();
//TypeArgumentList will always have a child node
identifierNode = typeArgumentList.ChildNodes().First();
return(true);
}
identifierNode = null;
return(false);
}
private static (string identifier, string name) GetIdentifierAndName(MemberAccessExpressionSyntax syntax)
{
var simpleAccess = syntax.ChildNodes().ToList();
var enumValue = simpleAccess.LastOrDefault() as IdentifierNameSyntax;
if (simpleAccess.FirstOrDefault() is IdentifierNameSyntax enumType && enumValue != null)
{
return(enumType.Identifier.Value.ToString(), enumValue.Identifier.Value.ToString());
}
if (simpleAccess.FirstOrDefault() is MemberAccessExpressionSyntax member && enumValue != null)
{
return(member.Name.Identifier.Value.ToString(), enumValue.Identifier.Value.ToString());
}
return(null, null);
}
public static object GetMemberValue(this MemberAccessExpressionSyntax member, SemanticModel semanticModel)
{
var node = member.ChildNodes().Skip(1).First();
if (node is IdentifierNameSyntax name)
{
var memberSymbol = semanticModel.GetSymbolInfo(name).Symbol;
var constant = semanticModel.GetConstantValue(name);
if (constant.HasValue)
{
return(constant.Value);
}
}
throw new NotImplementedException();
}
private StubbedCall StubMsTestMethodOrPropertyCall(ExpressionSyntax originalNode, MemberAccessExpressionSyntax member, ExpressionSyntax returnExpression, INamedTypeSymbol typeSymbol = null)
{
if (typeSymbol == null)
{
var identifier = member.Expression as IdentifierNameSyntax;
if (identifier == null)
{
return(null);
}
var symbol = semanticModel.GetSymbolInfo(identifier).Symbol;
typeSymbol = (symbol as ILocalSymbol)?.Type as INamedTypeSymbol;
if (typeSymbol == null)
{
return(null);
}
}
string typeToMock;
if (!msTestHelper.IsStub(typeSymbol, out typeToMock))
{
return(null);
}
var variableName = member.ChildNodes().OfType <IdentifierNameSyntax>().FirstOrDefault();
if (variableName == null)
{
return(null);
}
var methodOrPropertyCallIdentifier = member.ChildNodes().OfType <SimpleNameSyntax>().LastOrDefault();
if (methodOrPropertyCallIdentifier == null)
{
return(null);
}
INamedTypeSymbol fakesDelegateType;
ImmutableArray <ITypeSymbol> methodTypeArguments;
if (!msTestHelper.IsFakesDelegateMethodOrPropertySetter(typeSymbol, methodOrPropertyCallIdentifier.Identifier.ValueText, out fakesDelegateType, out methodTypeArguments))
{
return(null);
}
string fakeCallName = methodOrPropertyCallIdentifier.Identifier.ValueText;
var lambdaArguments = new List <ITypeSymbol>();
ITypeSymbol returnType = null;
if (fakesDelegateType.TypeParameters.Length > 0)
{
IEnumerable <ITypeSymbol> typeArguments = null;
if (fakesDelegateType.TypeParameters.Last().Name == "TResult")
{
var last = fakesDelegateType.TypeArguments.Last();
typeArguments = fakesDelegateType.TypeArguments.Where((t, i) => i < (fakesDelegateType.TypeArguments.Length - 1));
returnType = last;
}
else
{
typeArguments = fakesDelegateType.TypeArguments;
}
if (typeArguments != null)
{
lambdaArguments = typeArguments.ToList();
}
}
var concreteLambdaArguments = lambdaArguments;
var hashsetGenericType = new Dictionary <ITypeSymbol, TypeSyntax>();
var genericMemberName = member.Name as GenericNameSyntax;
if (genericMemberName != null)
{
var realTypeArguments = genericMemberName.TypeArgumentList.Arguments;
for (int i = 0; i < realTypeArguments.Count; i++)
{
var genericType = methodTypeArguments[i];
var realType = realTypeArguments[i];
hashsetGenericType[genericType] = realType;
}
concreteLambdaArguments = lambdaArguments.ToList();
for (int i = 0; i < lambdaArguments.Count; i++)
{
var lambdaArgument = concreteLambdaArguments[i] as INamedTypeSymbol;
if (lambdaArgument != null && lambdaArgument.IsGenericType) // null check needed since ArrayType is not an INamedTypeSymbol
{
var concreteArguments = lambdaArgument.TypeArguments.Select(arg =>
{
if (arg.TypeKind != TypeKind.TypeParameter)
{
return(arg);
}
return(semanticModel.GetTypeInfo(hashsetGenericType[arg]).Type);
});
var unbound = lambdaArgument.ConstructUnboundGenericType();
var newLambdaArgument = lambdaArgument.ConstructedFrom.Construct(concreteArguments.ToArray());
concreteLambdaArguments[i] = newLambdaArgument;
}
}
}
var originalType = typeSymbol.BaseType.TypeArguments.FirstOrDefault() as INamedTypeSymbol;
if (originalType == null)
{
return(null);
}
var originalMethodOrPropertySymbol = msTestHelper.GetOriginalSymbolFromFakeCallName(fakeCallName, lambdaArguments, originalType, fakesDelegateType.TypeParameters);
if (originalMethodOrPropertySymbol == null)
{
return(null);
}
var originalMethodSymbol = originalMethodOrPropertySymbol as IMethodSymbol;
if (originalMethodSymbol != null && originalMethodSymbol.TypeArguments.Length > 0)
{
var typeArguments = originalMethodSymbol.TypeArguments.Select(t => {
var concreteType = hashsetGenericType.Where(pair => pair.Key.Name == t.Name).Select(pair => pair.Value).FirstOrDefault();
if (concreteType != null)
{
return(semanticModel.GetTypeInfo(concreteType).Type);
}
else
{
// can happen for stubbed methods like Find<E>(), in that case generic type E must be explicitely passed
// however MsTest tests may declare it this way: instance.FindOf1(() => ...), where ... has to return an instance of E
// in that case the type is inferred
var invocationExpression = originalNode as InvocationExpressionSyntax;
if (invocationExpression != null)
{
var expressionArgument = invocationExpression.ArgumentList.Arguments.FirstOrDefault()?.Expression;
if (expressionArgument != null)
{
var expressionType = semanticModel.GetTypeInfo(expressionArgument).ConvertedType as INamedTypeSymbol;
if (expressionType != null)
{
return(expressionType?.TypeArguments.FirstOrDefault()); // type which is inferred
}
}
}
return(null);
}
});
originalMethodOrPropertySymbol = originalMethodSymbol.Construct(typeArguments.Where(t => t != null).ToArray());
}
var msStubbed = new StubbedMethodOrProperty(originalType, originalMethodOrPropertySymbol, concreteLambdaArguments, returnType);
var msStub = new StubbedCall(variableName, msStubbed, returnExpression, originalNode.GetLeadingTrivia(), originalNode.GetTrailingTrivia());
return(msStub);
}
private Location GetMemberInvocationLocation([NotNull] MemberAccessExpressionSyntax memberAccessSyntax)
{
SyntaxNode lastChild = memberAccessSyntax.ChildNodes().LastOrDefault();
return(lastChild != null?lastChild.GetLocation() : memberAccessSyntax.GetLocation());
}
