private static BlockSyntax GenerateAsyncProxyCall(string proxyClass, WebIdlMemberDefinition memberDefinition)
{
/*
* public static async Task<string> MethodNameAsync(string arg1, string arg2)
* {
* var asyncJsRunTime = JSRuntime.Current;
* return await asyncJsRunTime.InvokeAsync<string>("proxyClass.methodName", arg1, arg2);
* }
*/
var methodName = memberDefinition.Body.Name.Escaped;
var asyncInvocation = SyntaxFactory.ParseExpression($@"await asyncJsRunTime.InvokeAsync<string>(""{proxyClass}.{methodName}"", message)");
var syntax = SyntaxFactory.ParseStatement("var asyncJsRunTime = this.asyncJsRunTime;");
var proxyFunctionArgument = SyntaxFactory.Argument(
SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
SyntaxFactory.Literal($"{proxyClass}.{methodName}")));
var arguments = memberDefinition.Body.Arguments.Select(CreateArgumentCallExpression);
var proxyCallArguments = new[] { proxyFunctionArgument }.Union(arguments);
var typeName = memberDefinition.Body.IdlType.TypeName ?? memberDefinition.Body.IdlType.IdlType[0].TypeName;
var isResultTypeVoid = typeName == "void";
var resultType = isResultTypeVoid
? SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword))
: SyntaxFactory.ParseTypeName(NameService.GetTypeName(memberDefinition.Body.IdlType.IdlType[0]));
var awaitExpress = SyntaxFactory.AwaitExpression(
SyntaxFactory.InvocationExpression(
SyntaxFactory.MemberAccessExpression(
kind: SyntaxKind.SimpleMemberAccessExpression,
expression: SyntaxFactory.IdentifierName("asyncJsRunTime"),
name: SyntaxFactory.GenericName(
identifier: SyntaxFactory.Identifier("InvokeAsync"),
typeArgumentList: SyntaxFactory.TypeArgumentList(
SyntaxFactory.SingletonSeparatedList <TypeSyntax>(resultType)))),
argumentList: SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList <ArgumentSyntax>(
proxyCallArguments))));
var lastStatement = isResultTypeVoid
? (StatementSyntax)SyntaxFactory.ExpressionStatement(awaitExpress)
: SyntaxFactory.ReturnStatement(awaitExpress);
return(SyntaxFactory.Block(
syntax,
lastStatement));
}
private static MemberDeclarationSyntax CreateInterfaceField(WebIdlMemberDefinition memberDefinition)
{
var name = memberDefinition.Name;
try
{
var constField = SyntaxFactory.FieldDeclaration(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.ParseTypeName(NameService.GetTypeName(memberDefinition.IdlType)))
.WithVariables(
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(NameService.GetValidIndentifier(memberDefinition.Name))))))
.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PublicKeyword)));
return(constField);
}
catch (Exception ex)
{
throw new InvalidOperationException($"Error during generation field {name}", ex);
}
}
private static MemberDeclarationSyntax CreateInterfaceOperation(string proxyClass, WebIdlMemberDefinition memberDefinition)
{
var name = memberDefinition.Body.Name.Escaped;
try
{
var returnTypeReference = memberDefinition.Body.IdlType;
var isAsyncCall = NameService.IsAsync(returnTypeReference);
if (isAsyncCall)
{
name += "Async";
}
var returnType = CreateType(returnTypeReference);
var arguments = memberDefinition.Body.Arguments.Select(CreateParameter);
var body = isAsyncCall
? GenerateAsyncProxyCall(proxyClass, memberDefinition)
: GenerateSyncProxyCall(proxyClass, memberDefinition);
var methodModifier = isAsyncCall
? SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.PublicKeyword),
SyntaxFactory.Token(SyntaxKind.AsyncKeyword))
: SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.PublicKeyword));
return(SyntaxFactory.MethodDeclaration(returnType, NameService.GetValidIndentifier(name))
.WithModifiers(methodModifier)
.WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(arguments)))
.WithBody(body));
}
catch (Exception ex)
{
throw new InvalidOperationException($"Error during generation operation {name}", ex);
}
}
private static MemberDeclarationSyntax CreateInterfaceMember(string proxyClass, WebIdlMemberDefinition memberDefinition)
{
// var name = memberDefinition.Body;
if (memberDefinition.Type == "operation")
{
return(CreateInterfaceOperation(proxyClass, memberDefinition));
}
if (memberDefinition.Type == "attribute")
{
return(CreateInterfaceAttribute(memberDefinition));
}
if (memberDefinition.Type == "field")
{
return(CreateInterfaceField(memberDefinition));
}
throw new InvalidDataException($"The member type {memberDefinition.Type} is not supported.");
}
