public CSharpSyntaxNode Convert(TypeAliasDeclaration node)
{
if (IsDelegateDeclaration(node))
{
return(CreateDelegateDeclaration(node));
}
return(SyntaxFactory.UsingDirective(SyntaxFactory.NameEquals(node.Name.Text), node.Type.ToCsNode <NameSyntax>()));
}
public int VisitTypeAliasDeclaration(TypeAliasDeclaration declaration)
{
_Writer.Write("type ");
_Writer.Write(declaration.Name);
_Writer.Write(" = ");
declaration.Type.WriteTypeReference(_Writer);
_Writer.WriteLine(';');
return(0);
}
private DelegateDeclarationSyntax CreateDelegateDeclaration(TypeAliasDeclaration node)
{
FunctionType fn = node.Type as FunctionType;
DelegateDeclarationSyntax csDelegateDeclaration = SyntaxFactory
.DelegateDeclaration(fn.Type.ToCsNode <TypeSyntax>(), node.Name.Text)
.AddParameterListParameters(fn.Parameters.ToCsNodes <ParameterSyntax>())
.AddModifiers(node.Modifiers.ToCsNodes <SyntaxToken>());;
if (node.TypeParameters.Count > 0)
{
csDelegateDeclaration = csDelegateDeclaration.AddTypeParameterListParameters(node.TypeParameters.ToCsNodes <TypeParameterSyntax>());
}
return(csDelegateDeclaration);
}
public void TestTypeAliasDeclaration()
{
TypeAliasDeclaration node = new TypeAliasDeclaration(GetSymbolAtom(), GetTypeParameterList(), PrimitiveType.NumberType, Declaration.DeclarationFlags.Export, DefaultLineInfo);
CheckSerializationRoundTrip(node);
}
/// <nodoc />
public virtual void Visit(TypeAliasDeclaration typeAliasDeclaration)
{
}
public static TypeAliasDefinition Create(TypeAliasDeclaration node)
{
return(new TypeAliasDefinition(node));
}
public TypeAliasDefinition(TypeAliasDeclaration node)
{
Node = node;
}
private bool IsDelegateDeclaration(TypeAliasDeclaration node)
{
return(node.Type.Kind == NodeKind.FunctionType);
}
private void AddMember(Type type, bool isDataContract, InterfaceDeclaration declaration, MemberInfo member, List <Type> processingTypes, Dictionary <Type, TypeAliasDeclaration> stringUnionEnums)
{
if (member.GetCustomAttribute <JsonIgnoreAttribute>() != null &&
member.GetCustomAttribute <IgnoreDataMemberAttribute>() != null)
{
return;
}
var dm = member.GetCustomAttribute <DataMemberAttribute>();
if (isDataContract && dm == null)
{
return;
}
var jp = member.GetCustomAttribute <JsonPropertyAttribute>();
var fd = new FieldDeclaration();
fd.FieldName = jp.PropertyName ?? dm?.Name ?? member.Name;
var ft = member is FieldInfo fld ? fld.FieldType : ((PropertyInfo)member).PropertyType;
if (ft.IsConstructedGenericType && ft.GetGenericTypeDefinition() == typeof(Nullable <>))
{
ft = ft.GenericTypeArguments[0];
fd.IsOptional = true;
}
else
{
fd.IsOptional = !ft.GetTypeInfo().IsValueType &&
((jp != null && jp.Required != Required.Default) ||
member.GetCustomAttribute <RequiredAttribute>() != null);
}
if (ft.GetTypeInfo().IsEnum &&
member.GetCustomAttribute <JsonConverterAttribute>()?.ConverterType == typeof(StringEnumConverter))
{
if (!stringUnionEnums.TryGetValue(ft, out var ta))
{
ta = new TypeAliasDeclaration();
ta.Name = GetTypeName(ft);
var ut = new UnionType();
foreach (var ftf in ft.GetTypeInfo().DeclaredFields)
{
var em = ftf.GetCustomAttribute <EnumMemberAttribute>();
if (isDataContract && em == null)
{
continue;
}
ut.ElementTypes.Add(new StringLiteralType()
{
Value = em?.Value ?? ftf.Name
});
}
ta.Type = ut;
stringUnionEnums[ft] = ta;
}
fd.FieldType = ta;
}
else
{
fd.FieldType = GetTypeReference(ft, processingTypes, stringUnionEnums);
}
declaration.Members.Add(fd);
}
