addded async support for linq with generated tests

Author: maca88

src/NHibernate.AsyncGenerator/AsyncConfiguration.cs

@@ -11,7 +11,5 @@ public class AsyncConfiguration
 		public AsyncLockConfiguration Lock { get; set; }
 
 		public AsyncCustomTaskTypeConfiguration CustomTaskType { get; set; } = new AsyncCustomTaskTypeConfiguration();
-
-		public string AttributeName { get; set; }
 	}
 }

src/NHibernate.AsyncGenerator/DocumentTransformer.cs

@@ -16,7 +16,7 @@ namespace NHibernate.AsyncGenerator
 {
 	public class DocumentTransformer
 	{
-		private List<ITransformerPlugin> _plugins = new List<ITransformerPlugin>();
+		private readonly List<ITransformerPlugin> _plugins = new List<ITransformerPlugin>();
 
 		private class TransformedNode
 		{
@@ -167,7 +167,6 @@ private MethodDeclarationSyntax TransformMethod(MethodInfo methodInfo)
 			if (!methodInfo.HasBody)
 			{
 				return methodInfo.Node
-							  .WithoutAttribute("Async")
 							  .ReturnAsTask(methodInfo.Symbol, taskConflict)
 							  .WithIdentifier(Identifier(methodInfo.Node.Identifier.Value + "Async"))
 							  .RemoveLeadingRegions();
@@ -327,13 +326,26 @@ private MethodDeclarationSyntax TransformMethod(MethodInfo methodInfo)
 									methodInfo.Node.TypeParameterList.Parameters.Select(o => IdentifierName(o.Identifier.ValueText))
 									)))
 					: (SimpleNameSyntax)IdentifierName(methodInfo.Node.Identifier.ValueText);
+				MemberAccessExpressionSyntax accessExpression = null;
+				if (methodInfo.Symbol.MethodKind == MethodKind.ExplicitInterfaceImplementation)
+				{
+					// Explicit implementations needs an explicit cast (ie. ((Type)this).SyncMethod() )
+					accessExpression = MemberAccessExpression(
+										SyntaxKind.SimpleMemberAccessExpression,
+										ParenthesizedExpression(
+											CastExpression(
+												IdentifierName(methodInfo.Symbol.ExplicitInterfaceImplementations.Single().ContainingType.Name),
+												ThisExpression())),
+										name);
+				}
+
 
-				var invocation = InvocationExpression(name)
+				var invocation = InvocationExpression(accessExpression ?? (ExpressionSyntax)name)
 					.WithArgumentList(
 						ArgumentList(
 							SeparatedList(
 								methodInfo.Node.ParameterList.Parameters
-										  .Select(o => Argument(IdentifierName(o.Identifier.ValueText)))
+										  .Select(o => Argument(IdentifierName(o.Identifier.Text)))
 								)));
 				if (methodInfo.Symbol.ReturnsVoid)
 				{
@@ -364,7 +376,6 @@ private MethodDeclarationSyntax TransformMethod(MethodInfo methodInfo)
 					.WithoutAttribute("MethodImpl");
 			}
 			methodNode = methodNode
-				.WithoutAttribute("Async")
 				.ReturnAsTask(methodInfo.Symbol, taskConflict)
 				.WithIdentifier(Identifier(methodNode.Identifier.Value + "Async"));
 
@@ -416,7 +427,7 @@ private TransformTypeResult TransformType(TypeInfo rootTypeInfo, bool onlyMissin
 						var refSpanLength = reference.Location.SourceSpan.Length;
 						if (refSpanStart < 0)
 						{
-							// cref
+							// TODO: cref
 							//var startSpan = reference.Location.SourceSpan.Start - rootTypeInfo.Node.GetLeadingTrivia().Span.Start;
 							//var crefNode = leadingTrivia.First(o => o.SpanStart == startSpan && o.Span.Length == refSpanLength);
 							continue;
@@ -512,7 +523,7 @@ private TransformTypeResult TransformType(TypeInfo rootTypeInfo, bool onlyMissin
 					}
 					// add missing members
 					var typeNode = rootTypeNode.GetAnnotatedNodes(metadata.NodeAnnotation).OfType<TypeDeclarationSyntax>().First();
-
+					// TODO: we should not include all members, we need to skip the methods that are not required
 					rootTypeNode = rootTypeNode.ReplaceNode(typeNode, typeNode.WithMembers(
 							typeNode.Members.Select(o => o.RemoveLeadingRegions()).ToSyntaxList()
 							.AddRange(
@@ -616,6 +627,7 @@ public DocumentTransformationResult Transform()
 			var taskConflict = false;
 			var asyncLockUsed = false;
 			var rewrittenNodes = new List<TransformedNode>();
+			var projectConfig = DocumentInfo.ProjectInfo.Configuration;
 
 			// TODO: handle global namespace
 			foreach (var namespaceInfo in DocumentInfo.Values.OrderBy(o => o.Node.SpanStart))
@@ -695,6 +707,16 @@ public DocumentTransformationResult Transform()
 				rootNode = rootNode.AddUsings(UsingDirective(NameSyntax(lockNamespace)));
 			}
 
+			var usingList = projectConfig.GetAdditionalUsings?.Invoke(DocumentInfo.RootNode);
+			if (usingList != null)
+			{
+				foreach (var us in usingList.Where(o => DocumentInfo.RootNode.Usings.All(u => u.Name.ToString() != o)))
+				{
+					rootNode = rootNode.AddUsings(UsingDirective(NameSyntax(us)));
+				}
+			}
+
+
 			if (!taskConflict && rootNode.Usings.All(o => o.Name.ToString() != "System.Threading.Tasks"))
 			{
 				rootNode = rootNode.AddUsings(UsingDirective(NameSyntax("System.Threading.Tasks")));

src/NHibernate.AsyncGenerator/MethodInfo.cs

@@ -34,6 +34,10 @@ public MethodInfo(TypeInfo typeInfo, IMethodSymbol symbol, MethodDeclarationSynt
 
 		public bool Missing { get; set; }
 
+		public bool Required { get; set; }
+
+		public MethodAsyncConversion? Conversion { get; set; }
+
 		public HashSet<MethodInfo> InvokedBy { get; } = new HashSet<MethodInfo>();
 
 		/// <summary>
@@ -103,7 +107,7 @@ public void CalculateIgnore(int deep = 0, HashSet<MethodInfo> processedMethodInf
 				return;
 			}
 
-			if (Missing || ImplementsAbstractMethod)
+			if (Missing || ImplementsAbstractMethod || Required)
 			{
 				foreach (var refResult in ReferenceResults)
 				{
@@ -148,20 +152,30 @@ public void CalculateIgnore(int deep = 0, HashSet<MethodInfo> processedMethodInf
 				return;
 			}
 
-			var dependencies = ReferenceResults
+			var relRefResults = ReferenceResults
 				.Union(GetAllRelatedMethods().ToList().SelectMany(o => o.ReferenceResults))
 				.ToList();
 
-			foreach (var refResult in dependencies)
+			foreach (var refResult in relRefResults)
+			{
+				refResult.CalculateIgnore(deep, processedMethodInfos);
+			}
+			Ignore = relRefResults.All(o => o.Ignore);
+
+			if (Ignore)
+			{
+				relRefResults = relRefResults.Except(ReferenceResults).ToList();
+			}
+
+			foreach (var refResult in relRefResults)
 			{
 				// if the reference cannot be async we should preserve the original method. TODO: what if the method has dependecies that are async
 				if (!refResult.CanBeAsync && refResult.MethodInfo != null)
 				{
 					refResult.MethodInfo.CanBeAsnyc = false;
 				}
-				refResult.CalculateIgnore(deep, processedMethodInfos);
 			}
-			Ignore = dependencies.All(o => o.Ignore);
+
 			_ignoreCalculating = false;
 			_ignoreCalculated = true;
 		}
@@ -272,12 +286,13 @@ public IEnumerable<MethodInfo> GetAllDependencies()
 
 		private void AnalyzeInvocationExpression(SyntaxNode node, SimpleNameSyntax nameNode, MethodReferenceResult result)
 		{
-			var selectClause = node.Ancestors()
-				.FirstOrDefault(o => o.IsKind(SyntaxKind.SelectClause));
-			if (selectClause != null) // await is not supported in select clause
+			var queryExpression = node.Ancestors()
+				.OfType<QueryExpressionSyntax>()
+				.FirstOrDefault();
+			if (queryExpression != null) // await is not supported in linq query
 			{
 				result.CanBeAsync = false;
-				Logger.Warn($"Cannot await async method in a select clause:\r\n{selectClause}\r\n");
+				Logger.Warn($"Cannot await async method in a query expression:\r\n{queryExpression}\r\n");
 				return;
 			}
 			var docInfo = TypeInfo.NamespaceInfo.DocumentInfo;
@@ -311,13 +326,31 @@ private void AnalyzeInvocationExpression(SyntaxNode node, SimpleNameSyntax nameN
 				return;
 			}
 
+
+			// Custom code TODO: move
+			if (nameNode.Identifier.ToString() == "ToList")
+			{
+				var beforeToListExpression = ((MemberAccessExpressionSyntax)((InvocationExpressionSyntax)node).Expression).Expression;
+				var operation = docInfo.SemanticModel.GetOperation(beforeToListExpression);
+				if (operation == null)
+				{
+					result.CanBeAsync = false;
+					Logger.Warn($"Cannot find operation for previous node of ToList:\r\n{beforeToListExpression}\r\n");
+				}
+				else if(operation.Type.Name != "IQueryable")
+				{
+					result.CanBeAsync = false;
+					Logger.Warn($"Operation for previous node of ToList is not IQueryable:\r\n{operation.Type.Name}\r\n");
+				}
+			}
+			// End custom code
+
 			var anonFunctionNode = node.Ancestors()
 				.OfType<AnonymousFunctionExpressionSyntax>()
 				.FirstOrDefault();
 			if (anonFunctionNode?.AsyncKeyword.IsMissing == false)
 			{
-				// Custom code
-				
+				// Custom code TODO: move
 				var methodArgTypeInfo = ModelExtensions.GetTypeInfo(docInfo.SemanticModel, anonFunctionNode);
 				var convertedType = methodArgTypeInfo.ConvertedType;
 				if (convertedType != null && convertedType.ContainingAssembly.Name == "nunit.framework" && 
@@ -329,7 +362,7 @@ private void AnalyzeInvocationExpression(SyntaxNode node, SimpleNameSyntax nameN
 					result.MakeAnonymousFunctionAsync = true;
 					return;
 				}
-				//end
+				// End custom code
 
 				result.CanBeAsync = false;
 				Logger.Warn($"Cannot await async method in an non async anonymous function:\r\n{anonFunctionNode}\r\n");
@@ -346,14 +379,14 @@ private void AnalyzeArgumentExpression(SyntaxNode node, SimpleNameSyntax nameNod
 				return;
 			}
 
-			// Custom code
+			// Custom code TODO: move
 			var convertedType = methodArgTypeInfo.ConvertedType;
 			if (convertedType.ContainingAssembly.Name == "nunit.framework" && convertedType.Name == "TestDelegate")
 			{
 				result.WrapInsideAsyncFunction = true;
 				return;
 			}
-			//end
+			// End custom code
 
 			var delegateMethod = (IMethodSymbol)methodArgTypeInfo.ConvertedType.GetMembers("Invoke").First();
 
@@ -479,7 +512,7 @@ public MethodReferenceResult AnalyzeReference(ReferenceLocation reference)
 			return result;
 		}
 
-		public List<AsyncCounterpartMethod> FindAsyncCounterpartMethodsWhitinBody(Dictionary<IMethodSymbol, IMethodSymbol> methodAsyncConterparts = null)
+		public async Task<List<AsyncCounterpartMethod>> FindAsyncCounterpartMethodsWhitinBody(Dictionary<IMethodSymbol, IMethodSymbol> methodAsyncConterparts = null)
 		{
 			var result = new List<AsyncCounterpartMethod>();
 			if (Node.Body == null)
@@ -503,10 +536,11 @@ public List<AsyncCounterpartMethod> FindAsyncCounterpartMethodsWhitinBody(Dictio
 				}
 				else
 				{
-					var config = TypeInfo.NamespaceInfo.DocumentInfo.ProjectInfo.Configuration;
+					var projectInfo = TypeInfo.NamespaceInfo.DocumentInfo.ProjectInfo;
+					var config = projectInfo.Configuration;
 					if (config.FindAsyncCounterpart != null)
 					{
-						asyncMethodSymbol = config.FindAsyncCounterpart.Invoke(methodSymbol.OriginalDefinition);
+						asyncMethodSymbol = await config.FindAsyncCounterpart.Invoke(projectInfo.Project, methodSymbol.OriginalDefinition).ConfigureAwait(false);
 					}
 					else
 					{
@@ -613,7 +647,9 @@ public void Analyze()
 			{
 				ReferenceResults.Add(AnalyzeReference(reference));
 			}
-			CanBeAsnyc = ReferenceResults.Any(o => o.CanBeAsync);
+			// TODO: TypeTransformation should be removed
+			CanBeAsnyc = ReferenceResults.Any(o => o.CanBeAsync) ||
+						 (Conversion == MethodAsyncConversion.ToAsync && TypeInfo.TypeTransformation == TypeTransformation.Partial);
 
 			// TODO: check if this is correct
 			if (TypeInfo.TypeTransformation == TypeTransformation.Partial && GetAllRelatedMethods().ToList().Any(o => o.InvokedBy.Any()))