private static MemberDeclarationSyntax GetTypeDefinitionCode(WebIdlTypeDefinition token)
{
MemberDeclarationSyntax memberDeclaration = null;
var type = token.Type;
if (type == "enum")
{
memberDeclaration = GenerateEnumCode(token);
}
if (type == "interface")
{
memberDeclaration = GenerateInterfaceCode(token);
}
if (type == "dictionary")
{
memberDeclaration = GenerateInterfaceCode(token);
}
if (type == "callback")
{
memberDeclaration = GenerateDelegate(token);
}
return(memberDeclaration);
}
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)));
//// Inherit BaseEntity<T> and implement IHaveIdentity: (public class Order : BaseEntity<T>, IHaveIdentity)
//classDeclaration = classDeclaration.AddBaseListTypes(
// SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName("BaseEntity<Order>")),
// SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName("IHaveIdentity")));
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 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 MemberDeclarationSyntax GenerateEnumCode(WebIdlTypeDefinition token)
{
var firstEnumMember = token.Values.FirstOrDefault();
MemberDeclarationSyntax memberDeclaration;
if (firstEnumMember.Type == "string")
{
memberDeclaration = GenerateStringEnum(token);
}
else
{
memberDeclaration = GenerateSimpleEnum(token);
}
return(memberDeclaration);
}
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 EnumDeclarationSyntax GenerateSimpleEnum(WebIdlTypeDefinition token)
{
// Create a class: (class Order)
var classDeclaration = SyntaxFactory.EnumDeclaration(token.Name);
// Add the public modifier: (public class Order)
classDeclaration = classDeclaration.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword));
//// Inherit BaseEntity<T> and implement IHaveIdentity: (public class Order : BaseEntity<T>, IHaveIdentity)
//classDeclaration = classDeclaration.AddBaseListTypes(
// SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName("BaseEntity<Order>")),
// SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName("IHaveIdentity")));
foreach (var enumMemberDefinition in token.Values)
{
// Create a field declaration: (private bool canceled;)
var fieldDeclaration = SyntaxFactory.EnumMemberDeclaration(enumMemberDefinition.Value);
// Add the field, the property and method to the class.
classDeclaration = classDeclaration.AddMembers(fieldDeclaration);
}
return(classDeclaration);
}
private static ClassDeclarationSyntax GenerateStringEnum(WebIdlTypeDefinition token)
{
// Create a class: (class Order)
var classDeclaration = SyntaxFactory.ClassDeclaration(token.Name)
.WithModifiers(SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.PublicKeyword)));
var enumType = SyntaxFactory.ParseTypeName(token.Name);
//// Inherit BaseEntity<T> and implement IHaveIdentity: (public class Order : BaseEntity<T>, IHaveIdentity)
//classDeclaration = classDeclaration.AddBaseListTypes(
// SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName("BaseEntity<Order>")),
// SyntaxFactory.SimpleBaseType(SyntaxFactory.ParseTypeName("IHaveIdentity")));
var backingField = SyntaxFactory.FieldDeclaration(
SyntaxFactory.VariableDeclaration(
SyntaxFactory.PredefinedType(
SyntaxFactory.Token(SyntaxKind.StringKeyword)))
.WithVariables(
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier("field")))))
.WithModifiers(SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.PrivateKeyword),
SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword)));
classDeclaration = classDeclaration.AddMembers(backingField);
var constructorMember = SyntaxFactory.ConstructorDeclaration(token.Name)
.WithParameterList(SyntaxFactory.ParameterList(
SyntaxFactory.SingletonSeparatedList <ParameterSyntax>(
SyntaxFactory.Parameter(
SyntaxFactory.Identifier("value"))
.WithType(SyntaxFactory.PredefinedType(
SyntaxFactory.Token(SyntaxKind.StringKeyword))))))
.WithExpressionBody(
SyntaxFactory.ArrowExpressionClause(
SyntaxFactory.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName("field"),
SyntaxFactory.IdentifierName("value"))))
.WithModifiers(SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.PrivateKeyword)))
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
classDeclaration = classDeclaration.AddMembers(constructorMember);
foreach (var enumMemberDefinition in token.Values)
{
var backingValue = SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
SyntaxFactory.Literal(enumMemberDefinition.Value));
var initializationValue = SyntaxFactory.ObjectCreationExpression(enumType)
.WithArgumentList(SyntaxFactory.ArgumentList(
SyntaxFactory.SingletonSeparatedList <ArgumentSyntax>(
SyntaxFactory.Argument(backingValue))));
var constField = SyntaxFactory.FieldDeclaration(
SyntaxFactory.VariableDeclaration(
enumType)
.WithVariables(
SyntaxFactory.SingletonSeparatedList <VariableDeclaratorSyntax>(
SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(NameService.ConvertFromWebIdlIdentifier(enumMemberDefinition.Value)))
.WithInitializer(
SyntaxFactory.EqualsValueClause(
initializationValue)))))
.WithModifiers(SyntaxFactory.TokenList(
SyntaxFactory.Token(SyntaxKind.PublicKeyword),
SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword),
SyntaxFactory.Token(SyntaxKind.StaticKeyword)));
// Add the field, the property and method to the class.
classDeclaration = classDeclaration.AddMembers(constField);
}
return(classDeclaration);
}
