public EnumDeclarationSyntax MakeUnionSelectorEnum(TypeDefinition def)
{
var whichEnum = EnumDeclaration(_names.UnionDiscriminatorEnum.ToString())
.AddModifiers(Public)
.AddBaseListTypes(SimpleBaseType(_names.Type <ushort>(Nullability.NonNullable)));
var discFields = def.Fields.Where(f => f.DiscValue.HasValue);
foreach (var discField in discFields)
{
whichEnum = whichEnum.AddMembers(
EnumMemberDeclaration(_names.GetCodeIdentifier(discField).Identifier)
.WithEqualsValue(
EqualsValueClause(LiteralExpression(
SyntaxKind.NumericLiteralExpression,
Literal(discField.DiscValue.Value)))));
}
var ndecl = EnumMemberDeclaration(_names.UnionDiscriminatorUndefined.ToString()).WithEqualsValue(
EqualsValueClause(
LiteralExpression(
SyntaxKind.NumericLiteralExpression,
Literal(SchemaModel.NoDiscriminant))));
whichEnum = whichEnum.AddMembers(ndecl);
return(whichEnum);
}
PropertyDeclarationSyntax MakePrimitiveProperty <T>(Field field, string readName)
{
return(MakeProperty(Type <T>(), null, _names.GetCodeIdentifier(field).ToString(),
readName,
nameof(Capnp.SerializerExtensions.WriteData),
field.BitOffset.Value,
ValueOf(field.DefaultValue.ScalarValue),
false,
field.DiscValue.HasValue,
true));
}
public MemberDeclarationSyntax MakeInterface(TypeDefinition type)
{
var ifaceDecl = InterfaceDeclaration(_names.MakeTypeName(type, NameUsage.Interface).Identifier)
.AddModifiers(Public)
.AddAttributeLists(
_names.MakeTypeDecorationAttributes(type.Id)
.AddAttributes(
Attribute(IdentifierName("Proxy"))
.AddArgumentListArguments(
AttributeArgument(
TypeOfExpression(_names.MakeGenericTypeNameForAttribute(type, NameUsage.Proxy)))),
Attribute(IdentifierName("Skeleton"))
.AddArgumentListArguments(
AttributeArgument(
TypeOfExpression(_names.MakeGenericTypeNameForAttribute(type, NameUsage.Skeleton))))));
if (type.GenericParameters.Count > 0)
{
ifaceDecl = ifaceDecl
.AddTypeParameterListParameters(MakeTypeParameters(type).ToArray())
.AddConstraintClauses(MakeTypeParameterConstraints(type).ToArray());
}
if (type.Superclasses.Count == 0)
{
ifaceDecl = ifaceDecl.AddBaseListTypes(SimpleBaseType(IdentifierName(nameof(IDisposable))));
}
else
{
foreach (var superClass in type.Superclasses)
{
ifaceDecl = ifaceDecl.AddBaseListTypes(
SimpleBaseType(_names.MakeTypeSyntax(
superClass, type,
TypeUsage.DomainClass,
Nullability.NonNullable)));
}
}
foreach (var method in type.Methods)
{
var methodDecl = MethodDeclaration(
TransformReturnType(method),
_names.GetCodeIdentifier(method).Identifier)
.AddParameterListParameters(TransformParameters(method))
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken));
if (method.GenericParameters.Count > 0)
{
methodDecl = methodDecl
.AddTypeParameterListParameters(MakeTypeParameters(method).ToArray())
.AddConstraintClauses(MakeTypeParameterConstraints(method).ToArray());
}
ifaceDecl = ifaceDecl.AddMembers(methodDecl);
}
return(ifaceDecl);
}
MemberDeclarationSyntax MakeUnionField(Field field)
{
var type = _names.MakeTypeSyntax(field.Type, field.DeclaringType, TypeUsage.DomainClassNullable);
switch (field.Type.Tag)
{
case TypeTag.Void:
return(null);
default:
return(PropertyDeclaration(type,
_names.GetCodeIdentifier(field).Identifier)
.AddModifiers(Public).AddAccessorListAccessors(
AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithExpressionBody(
ArrowExpressionClause(
ConditionalExpression(
BinaryExpression(
SyntaxKind.EqualsExpression,
_names.UnionDiscriminatorField.IdentifierName,
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
_names.UnionDiscriminatorEnum.IdentifierName,
_names.GetCodeIdentifier(field).IdentifierName)),
CastExpression(type,
_names.UnionContentField.IdentifierName),
LiteralExpression(
SyntaxKind.NullLiteralExpression))))
.WithSemicolonToken(
Token(SyntaxKind.SemicolonToken)),
AccessorDeclaration(
SyntaxKind.SetAccessorDeclaration)
.WithBody(
Block(
ExpressionStatement(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
_names.UnionDiscriminatorField.IdentifierName,
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
_names.UnionDiscriminatorEnum.IdentifierName,
_names.GetCodeIdentifier(field).IdentifierName))),
ExpressionStatement(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
_names.UnionContentField.IdentifierName,
IdentifierName("value")))))));
}
}
PropertyDeclarationSyntax MakeReadPrimitiveProperty <T>(Field field, string readName)
{
return(MakeReadProperty(
_names.Type <T>(Nullability.NonNullable),
_names.GetCodeIdentifier(field).ToString(),
readName,
field.BitOffset.Value,
ValueOf(field.DefaultValue.ScalarValue),
null,
field.DiscValue.HasValue));
}
ParameterSyntax[] TransformParameters(Method method)
{
var list = new List <ParameterSyntax>();
if (method.Params.Count > 0)
{
var arg0 = method.Params[0];
if (arg0.Name == null)
{
list.Add(Parameter(_names.AnonymousParameter.Identifier)
.WithType(_names.MakeTypeSyntax(arg0.Type, method.DeclaringInterface, TypeUsage.DomainClass, Nullability.NullableRef)));
}
else
{
foreach (var arg in method.Params)
{
list.Add(Parameter(_names.GetCodeIdentifier(arg).Identifier)
.WithType(_names.MakeTypeSyntax(arg.Type, method.DeclaringInterface, TypeUsage.DomainClass, Nullability.NullableRef)));
}
}
}
list.Add(Parameter(_names.CancellationTokenParameter.Identifier)
.WithType(IdentifierName(nameof(CancellationToken)))
.WithDefault(EqualsValueClause(LiteralExpression(
SyntaxKind.DefaultLiteralExpression,
Token(SyntaxKind.DefaultKeyword)))));
return(list.ToArray());
}