private static ParameterSyntax CreateParameter(WebIdlArgumentDefinition arg)
{
var item = SyntaxFactory.Identifier(NameService.GetValidIndentifier(arg.EscapedName));
return(SyntaxFactory.Parameter(item)
.WithType(CreateType(arg.IdlType)));
}
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 ClassDeclarationSyntax GenerateInterfaceCode(WebIdlTypeDefinition token)
{
var name = token.Name;
try
{
var classDeclaration = SyntaxFactory.ClassDeclaration(name)
.WithModifiers(SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.PublicKeyword),
SyntaxFactory.Token(SyntaxKind.PartialKeyword)));
var arguments = new[]
{
Parameter(Identifier(NameService.GetValidIndentifier("asyncJsRunTime")))
.WithType(ParseTypeName("IJSRuntime")),
};
var constructorMember = ConstructorDeclaration(NameService.GetValidIndentifier(name))
.WithModifiers(TokenList(
Token(SyntaxKind.PublicKeyword)))
.WithParameterList(ParameterList(SeparatedList(arguments)))
.WithBody(Block(
ParseStatement("this.asyncJsRunTime = asyncJsRunTime;")));
classDeclaration = classDeclaration.AddMembers(constructorMember);
var asyncJsRunTimeField = SyntaxFactory.FieldDeclaration(
VariableDeclaration(
ParseTypeName("IJSRuntime"))
.WithVariables(
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(NameService.GetValidIndentifier("asyncJsRunTime"))))))
.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.PrivateKeyword)));
classDeclaration = classDeclaration.AddMembers(asyncJsRunTimeField);
var proxyClass = $"Blazor{token.Name}Proxy";
foreach (var enumMemberDefinition in token.Members)
{
var constField = CreateInterfaceMember(proxyClass, enumMemberDefinition);
// Add the field, the property and method to the class.
classDeclaration = classDeclaration.AddMembers(constField);
}
return(classDeclaration);
}
catch (Exception ex)
{
throw new InvalidOperationException($"Error during generation interface {name}", ex);
}
}
private static DelegateDeclarationSyntax GenerateDelegate(WebIdlTypeDefinition memberDefinition)
{
var name = memberDefinition.Name;
try
{
var returnTypeReference = memberDefinition.IdlType;
var returnType = CreateType(returnTypeReference);
var arguments = memberDefinition.Arguments.Select(CreateParameter);
var methodModifier = SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.PublicKeyword));
return(SyntaxFactory.DelegateDeclaration(returnType, NameService.GetValidIndentifier(name))
.WithModifiers(methodModifier)
.WithParameterList(SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(arguments))));
}
catch (Exception ex)
{
throw new InvalidOperationException($"Error during generation operation {name}", ex);
}
}
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 ArgumentSyntax CreateArgumentCallExpression(WebIdlArgumentDefinition argumentDefinition)
{
return(SyntaxFactory.Argument(
SyntaxFactory.IdentifierName(NameService.GetValidIndentifier(argumentDefinition.Name))));
}