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()); }