Skip to content

Commit 841ae76

Browse files
maca88hazzik
maca88
authored and
hazzik
committed
generated tests are now building
1 parent 2c984f1 commit 841ae76

File tree

593 files changed

+64574
-106
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

593 files changed

+64574
-106
lines changed

‎src/NHibernate.AsyncGenerator/DocumentWriter.cs

Lines changed: 45 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@
77
using Microsoft.CodeAnalysis;
88
using Microsoft.CodeAnalysis.CSharp;
99
using Microsoft.CodeAnalysis.CSharp.Syntax;
10+
using Microsoft.CodeAnalysis.FindSymbols;
1011
using NHibernate.AsyncGenerator.Extensions;
1112
using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
1213

@@ -99,13 +100,13 @@ private BlockSyntax AsyncLockBlock(BlockSyntax block)
99100
);
100101
}
101102

102-
private MethodDeclarationSyntax RewiteMethod(MethodInfo methodInfo, MethodAnalyzeResult analyzeResult)
103+
private MethodDeclarationSyntax RewiteMethod(MethodInfo methodInfo, MethodAnalyzeResult analyzeResult, bool taskConflict)
103104
{
104105
if (!analyzeResult.HasBody)
105106
{
106107
return methodInfo.Node
107108
.WithoutAttribute("Async")
108-
.ReturnAsTask(methodInfo.Symbol)
109+
.ReturnAsTask(methodInfo.Symbol, taskConflict)
109110
.WithIdentifier(Identifier(methodInfo.Node.Identifier.Value + "Async"));
110111
}
111112

@@ -179,6 +180,24 @@ private MethodDeclarationSyntax RewiteMethod(MethodInfo methodInfo, MethodAnalyz
179180
}
180181
else
181182
{
183+
if (referenceResult.PassedAsArgument)
184+
{
185+
if (referenceResult.WrapInsideAsyncFunction)
186+
{
187+
var argumentNode = nameNode.Ancestors().OfType<ArgumentSyntax>().First();
188+
var expressionNode = argumentNode.ChildNodes().OfType<ExpressionSyntax>().First();
189+
var lambdaNode = ParenthesizedLambdaExpression(
190+
AwaitExpression(
191+
InvocationExpression(expressionNode.ReplaceNode(nameNode,
192+
nameNode.WithIdentifier(Identifier(nameNode.Identifier.Value + "Async"))))))
193+
.WithAsyncKeyword(
194+
Token(SyntaxKind.AsyncKeyword));
195+
methodNode = methodNode
196+
.ReplaceNode(expressionNode, lambdaNode);
197+
}
198+
continue;
199+
}
200+
182201
var lastAwaitAnnotation = Guid.NewGuid().ToString();
183202
// await method
184203
var invocationNode = nameNode.Ancestors().OfType<InvocationExpressionSyntax>().First();
@@ -196,6 +215,17 @@ private MethodDeclarationSyntax RewiteMethod(MethodInfo methodInfo, MethodAnalyz
196215
methodNode = methodNode.ReplaceNode(invocationNode, awaitNode);
197216
awaitNode = methodNode.GetAnnotatedNodes(lastAwaitAnnotation).Single();
198217
awaitsPlacements.Add(awaitNode.SpanStart, awaitLength);
218+
219+
if (!referenceResult.MakeAnonymousFunctionAsync) continue;
220+
var functionNode = awaitNode.Ancestors().OfType<AnonymousFunctionExpressionSyntax>().First();
221+
if (functionNode.AsyncKeyword.Kind() == SyntaxKind.AsyncKeyword) continue;
222+
var functionAnnotation = Guid.NewGuid().ToString();
223+
var asyncFunctionNode = functionNode.AddAsync().WithAdditionalAnnotations(new SyntaxAnnotation(functionAnnotation));
224+
methodNode = methodNode.ReplaceNode(functionNode, asyncFunctionNode);
225+
var asyncKeywordToken = methodNode.GetAnnotatedNodes(functionAnnotation)
226+
.OfType<AnonymousFunctionExpressionSyntax>().First()
227+
.AsyncKeyword;
228+
awaitsPlacements.Add(asyncKeywordToken.SpanStart, asyncKeywordToken.Span.Length);
199229
}
200230
}
201231

@@ -247,7 +277,7 @@ private MethodDeclarationSyntax RewiteMethod(MethodInfo methodInfo, MethodAnalyz
247277
}
248278
methodNode = methodNode
249279
.WithoutAttribute("Async")
250-
.ReturnAsTask(methodInfo.Symbol)
280+
.ReturnAsTask(methodInfo.Symbol, taskConflict)
251281
.WithIdentifier(Identifier(methodNode.Identifier.Value + "Async"));
252282

253283
if (analyzeResult.MustRunSynchronized || (!analyzeResult.CanSkipAsync && !analyzeResult.Yields && analyzeResult.CanBeAsnyc))
@@ -265,9 +295,16 @@ public void Write()
265295
var namespaceNodes = new List<MemberDeclarationSyntax>();
266296
var customTask = Configuration.Async.CustomTaskType;
267297
var tasksUsed = false;
298+
var taskConflict = false;
268299
foreach (var namespaceInfo in DocumentInfo.Values.OrderBy(o => o.Node.SpanStart))
269300
{
270301
var namespaceNode = namespaceInfo.Node;
302+
303+
if (!DocumentInfo.ProjectInfo.IsNameUniqueInsideNamespace(namespaceInfo.Symbol, "Task"))
304+
{
305+
taskConflict = true;
306+
}
307+
271308
var typeNodes = new List<MemberDeclarationSyntax>();
272309
foreach (var typeInfo in namespaceInfo.Values.OrderBy(o => o.Node.SpanStart))
273310
{
@@ -279,7 +316,7 @@ public void Write()
279316
var methodAnalyzeResult = methodInfo.Analyze();
280317
tasksUsed |= methodAnalyzeResult.CanSkipAsync || methodAnalyzeResult.IsEmpty || methodAnalyzeResult.Yields || !methodAnalyzeResult.CanBeAsnyc;
281318
asyncLock |= methodAnalyzeResult.MustRunSynchronized;
282-
memberNodes.Add(RewiteMethod(methodInfo, methodAnalyzeResult));
319+
memberNodes.Add(RewiteMethod(methodInfo, methodAnalyzeResult, taskConflict));
283320
}
284321
// TODO: inifinite levels of nested types
285322
foreach (var subTypeInfo in typeInfo.TypeInfos.Values.OrderBy(o => o.Node.SpanStart))
@@ -292,7 +329,7 @@ public void Write()
292329
var methodAnalyzeResult = methodInfo.Analyze();
293330
tasksUsed |= methodAnalyzeResult.CanSkipAsync || methodAnalyzeResult.IsEmpty || methodAnalyzeResult.Yields || !methodAnalyzeResult.CanBeAsnyc;
294331
subAsyncLock |= methodAnalyzeResult.MustRunSynchronized;
295-
subMemberNodes.Add(RewiteMethod(methodInfo, methodAnalyzeResult));
332+
subMemberNodes.Add(RewiteMethod(methodInfo, methodAnalyzeResult, taskConflict));
296333
}
297334
if (subAsyncLock)
298335
{
@@ -347,7 +384,9 @@ public void Write()
347384
.WithMembers(List(typeNodes)));
348385
}
349386

350-
if (rootNode.Usings.All(o => o.Name.ToString() != "System.Threading.Tasks"))
387+
388+
389+
if (!taskConflict && rootNode.Usings.All(o => o.Name.ToString() != "System.Threading.Tasks"))
351390
{
352391
rootNode = rootNode.AddUsings(UsingDirective(IdentifierName("System.Threading.Tasks")));
353392
}

‎src/NHibernate.AsyncGenerator/Extensions/SyntaxExtensions.Async.cs

Lines changed: 12 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,14 @@ namespace NHibernate.AsyncGenerator.Extensions
1919
{
2020
internal static partial class SyntaxExtensions
2121
{
22-
public static T AddAsync<T>(this SyntaxNode oldNode, T root, CancellationToken cancellationToken = default(CancellationToken))
22+
23+
public static SyntaxNode AddAsync(this SyntaxNode oldNode)
24+
{
25+
var nodeToModify = GetContainingMember(oldNode);
26+
return nodeToModify == null ? oldNode : ConvertToAsync(nodeToModify) ?? oldNode;
27+
}
28+
29+
public static T AddAsync<T>(this SyntaxNode oldNode, T root)
2330
where T : SyntaxNode
2431
{
2532
var nodeToModify = GetContainingMember(oldNode);
@@ -28,7 +35,7 @@ internal static partial class SyntaxExtensions
2835
return null;
2936
}
3037

31-
var modifiedNode = ConvertToAsync(nodeToModify, cancellationToken);
38+
var modifiedNode = ConvertToAsync(nodeToModify);
3239
if (modifiedNode == oldNode)
3340
{
3441
return root;
@@ -69,15 +76,15 @@ private static SyntaxNode GetContainingMember(SyntaxNode oldNode)
6976
return null;
7077
}
7178

72-
private static SyntaxNode ConvertMethodToAsync(SyntaxNode methodNode, CancellationToken cancellationToken)
79+
private static SyntaxNode ConvertMethodToAsync(SyntaxNode methodNode)
7380
{
7481
return AddAsyncKeyword(methodNode);
7582
}
7683

77-
private static SyntaxNode ConvertToAsync(SyntaxNode node, CancellationToken cancellationToken)
84+
private static SyntaxNode ConvertToAsync(SyntaxNode node)
7885
{
7986
return node.TypeSwitch(
80-
(MethodDeclarationSyntax methodNode) => ConvertMethodToAsync(methodNode, cancellationToken),
87+
(MethodDeclarationSyntax methodNode) => ConvertMethodToAsync(methodNode),
8188
(ParenthesizedLambdaExpressionSyntax parenthesizedLambda) => ConvertParenthesizedLambdaToAsync(parenthesizedLambda),
8289
(SimpleLambdaExpressionSyntax simpleLambda) => ConvertSimpleLambdaToAsync(simpleLambda),
8390
(AnonymousMethodExpressionSyntax anonymousMethod) => ConvertAnonymousMethodToAsync(anonymousMethod),

‎src/NHibernate.AsyncGenerator/Extensions/SyntaxExtensions.Await.cs

Lines changed: 40 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@
1111
using Microsoft.CodeAnalysis.CSharp.Syntax;
1212
using Microsoft.CodeAnalysis.Formatting;
1313
using Microsoft.CodeAnalysis.Simplification;
14+
using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
1415

1516
namespace NHibernate.AsyncGenerator.Extensions
1617
{
@@ -25,24 +26,24 @@ public static TypeDeclarationSyntax AddGeneratedCodeAttribute(this TypeDeclarati
2526
typeDeclaration = typeDeclaration.ReplaceToken(modifier.Value, modifier.Value.WithLeadingTrivia(SyntaxTriviaList.Empty));
2627
}
2728

28-
var attrList = SyntaxFactory.AttributeList(
29-
SyntaxFactory.Token(SyntaxKind.OpenBracketToken).WithLeadingTrivia(modifier?.LeadingTrivia ?? SyntaxTriviaList.Empty),
29+
var attrList = AttributeList(
30+
Token(SyntaxKind.OpenBracketToken).WithLeadingTrivia(modifier?.LeadingTrivia ?? SyntaxTriviaList.Empty),
3031
null,
31-
SyntaxFactory.SeparatedList(
32+
SeparatedList(
3233
new List<AttributeSyntax>
3334
{
34-
SyntaxFactory.Attribute(SyntaxFactory.IdentifierName("System.CodeDom.Compiler.GeneratedCode(\"AsyncGenerator\", \"1.0.0\")"))
35+
Attribute(IdentifierName("System.CodeDom.Compiler.GeneratedCode(\"AsyncGenerator\", \"1.0.0\")"))
3536
}
3637
),
37-
SyntaxFactory.Token(SyntaxKind.CloseBracketToken)
38+
Token(SyntaxKind.CloseBracketToken)
3839
);
3940
if (keepExisting)
4041
{
4142
return typeDeclaration
4243
.WithAttributes(typeDeclaration.AttributeLists.Add(attrList));
4344
}
4445
return typeDeclaration
45-
.WithAttributes(SyntaxFactory.List(new List<AttributeListSyntax> { attrList }));
46+
.WithAttributes(List(new List<AttributeListSyntax> { attrList }));
4647
}
4748

4849
public static TypeDeclarationSyntax AddPartial(this TypeDeclarationSyntax typeDeclaration)
@@ -51,13 +52,13 @@ public static TypeDeclarationSyntax AddPartial(this TypeDeclarationSyntax typeDe
5152
if (interfaceDeclaration != null && !typeDeclaration.Modifiers.Any(o => o.IsKind(SyntaxKind.PartialKeyword)))
5253
{
5354
return interfaceDeclaration
54-
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PartialKeyword));
55+
.AddModifiers(Token(SyntaxKind.PartialKeyword));
5556
}
5657
var classDeclaration = typeDeclaration as ClassDeclarationSyntax;
5758
if (classDeclaration != null && !classDeclaration.Modifiers.Any(o => o.IsKind(SyntaxKind.PartialKeyword)))
5859
{
5960
return classDeclaration
60-
.AddModifiers(SyntaxFactory.Token(SyntaxKind.PartialKeyword));
61+
.AddModifiers(Token(SyntaxKind.PartialKeyword));
6162
}
6263
return typeDeclaration;
6364
}
@@ -110,31 +111,52 @@ public static TypeDeclarationSyntax WithoutAttributes(this TypeDeclarationSyntax
110111
if (interfaceDeclaration != null)
111112
{
112113
return interfaceDeclaration
113-
.WithAttributeLists(SyntaxFactory.List<AttributeListSyntax>());
114+
.WithAttributeLists(List<AttributeListSyntax>());
114115
}
115116
var classDeclaration = typeDeclaration as ClassDeclarationSyntax;
116117
if (classDeclaration != null)
117118
{
118119
return classDeclaration
119-
.WithAttributeLists(SyntaxFactory.List<AttributeListSyntax>());
120+
.WithAttributeLists(List<AttributeListSyntax>());
120121
}
121122
return typeDeclaration;
122123
}
123124

124125
public static MethodDeclarationSyntax ReturnAsTask(
125126
this MethodDeclarationSyntax methodNode,
126-
IMethodSymbol methodSymbol)
127+
IMethodSymbol methodSymbol, bool withFullName)
127128
{
128129
var leadingTrivia = methodNode.ReturnType.GetLeadingTrivia();
129130
if (methodSymbol.ReturnsVoid)
130131
{
132+
var taskNode = IdentifierName("Task")
133+
.WithLeadingTrivia(leadingTrivia);
131134
return methodNode
132-
.WithReturnType(SyntaxFactory.IdentifierName("Task").WithLeadingTrivia(leadingTrivia));
135+
.WithReturnType(
136+
withFullName
137+
? QualifiedName(
138+
QualifiedName(
139+
QualifiedName(
140+
IdentifierName("System"),
141+
IdentifierName("Threading")),
142+
IdentifierName("Tasks")),
143+
taskNode)
144+
: (TypeSyntax) taskNode);
133145
}
134-
return methodNode
135-
.WithReturnType(SyntaxFactory.GenericName("Task")
146+
var genericTaskNode = GenericName("Task")
136147
.WithLeadingTrivia(leadingTrivia)
137-
.AddTypeArgumentListArguments(methodNode.ReturnType.WithoutLeadingTrivia()));
148+
.AddTypeArgumentListArguments(methodNode.ReturnType.WithoutLeadingTrivia());
149+
return methodNode
150+
.WithReturnType(
151+
withFullName
152+
? QualifiedName(
153+
QualifiedName(
154+
QualifiedName(
155+
IdentifierName("System"),
156+
IdentifierName("Threading")),
157+
IdentifierName("Tasks")),
158+
genericTaskNode)
159+
: (TypeSyntax) genericTaskNode);
138160
}
139161

140162
public static SyntaxNode AddAwait(this SyntaxNode oldNode)
@@ -148,7 +170,7 @@ public static SyntaxNode AddAwait(this SyntaxNode oldNode)
148170
var nextToken = expression.Parent.ChildNodesAndTokens().FirstOrDefault(o => o.SpanStart >= expression.Span.End); // token can be in a new line
149171
if (nextToken.IsKind(SyntaxKind.DotToken) || nextToken.IsKind(SyntaxKind.BracketedArgumentList))
150172
{
151-
awaitNode = SyntaxFactory.ParenthesizedExpression(awaitNode);
173+
awaitNode = ParenthesizedExpression(awaitNode);
152174
}
153175

154176
return awaitNode;
@@ -182,13 +204,13 @@ private static ExpressionSyntax ConvertToAwaitExpression(ExpressionSyntax expres
182204
var span = expWithTrailing.GetLocation().GetLineSpan().Span;
183205
if (span.Start.Line == span.End.Line && !expWithTrailing.DescendantTrivia().Any(trivia => trivia.IsKind(SyntaxKind.SingleLineCommentTrivia)))
184206
{
185-
return SyntaxFactory.AwaitExpression(SyntaxFactory.ParenthesizedExpression(expWithTrailing))
207+
return AwaitExpression(ParenthesizedExpression(expWithTrailing))
186208
.WithLeadingTrivia(expression.GetLeadingTrivia())
187209
.WithAdditionalAnnotations(Formatter.Annotation);
188210
}
189211
}
190212

191-
return SyntaxFactory.AwaitExpression(expression.WithoutTrivia().Parenthesize())
213+
return AwaitExpression(expression.WithoutTrivia().Parenthesize())
192214
.WithTriviaFrom(expression)
193215
.WithAdditionalAnnotations(Simplifier.Annotation, Formatter.Annotation);
194216
}

0 commit comments

Comments
 (0)