private static TypeSyntax CreateType(WebIdlTypeReference returnTypeReference)
{
var typeName = NameService.GetTypeName(returnTypeReference);
var returnType = SyntaxFactory.ParseTypeName(typeName);
return(returnType);
}
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);
}
}
