/// <summary>
/// Load extends statement list.
/// </summary>
/// <param name="declaration">The declaration to load.</param>
/// <param name="resolver">The resolver to resolve dependencies.</param>
private void LoadExtends(AGenericDeclaration <TNode> declaration, IDeclarationResolver resolver)
{
var declarationType = declaration.GetData <Type>();
var extendedInterfaces = declarationType.GetInterfaces();
if ((extendedInterfaces != null && extendedInterfaces.Any()) || declarationType.BaseType != null)
{
var uses = new List <IDeclarationUse <SyntaxNode> >();
if (declarationType.BaseType != null)
{
uses.Add(GetDeclarationUseFrom(declarationType.BaseType, resolver));
}
if (extendedInterfaces != null)
{
foreach (var extendedInterface in extendedInterfaces)
{
uses.Add(GetDeclarationUseFrom(extendedInterface, resolver));
}
}
declaration.Extends = uses;
}
else
{
declaration.Extends = Array.Empty <IDeclarationUse <SyntaxNode> >();
}
}
/// <summary>
/// Load member list.
/// </summary>
/// <param name="declaration">The declaration to load.</param>
/// <param name="resolver">The resolver to resolve dependencies.</param>
private void LoadMembers(AGenericDeclaration <TNode> declaration, IDeclarationResolver resolver)
{
var memberList = new List <IMemberDeclaration <SyntaxNode> >();
try
{
foreach (var property in declaration.GetData <Type>().GetProperties())
{
var propertyType = GetDeclarationUseFrom(property.PropertyType, resolver);
memberList.Add(
new PropertyDeclaration(
property.Name,
propertyType,
new ReflectionPropertySyntaxNodeProvider(property, propertyType.SyntaxNodeProvider),
property.CanRead,
property.CanWrite));
}
foreach (var method in declaration.GetData <Type>().GetMethods())
{
if (!method.IsPrivate)
{
var returnType = GetDeclarationUseFrom(method.ReturnType, resolver);
memberList.Add(
new MethodDeclaration(
method.Name,
returnType,
new ReflectionMethodSyntaxNodeProvider(method, returnType.SyntaxNodeProvider)));
}
}
}
catch (TypeLoadException e)
{
this.logger?.LogWarning($"Could not load properties from {declaration.GetData<Type>()} ({e.Message})");
}
catch (FileNotFoundException e)
{
this.logger?.LogWarning($"Could not load properties from {declaration.GetData<Type>()} ({e.Message})");
}
declaration.Members = memberList.Any() ? memberList.ToArray() : Array.Empty <IMemberDeclaration <SyntaxNode> >();
}
private void LoadAttributes(AGenericDeclaration <TNode> declaration, IDeclarationResolver resolver)
{
var attributeList = new List <IAttributeUse>();
var declType = declaration.GetData <Type>();
foreach (var customAttribute in declType.CustomAttributes)
{
attributeList.Add(
new AttributeUse(
GetDeclarationUseFrom(customAttribute.AttributeType, resolver).Declaration,
new ReflectionAttributeSyntaxNodeProvider(customAttribute)));
}
declaration.Attributes = attributeList.Any() ? attributeList.ToArray() : Array.Empty <IAttributeUse>();
}
/// <summary>
/// Load the generic parameters from the type parameter list node.
/// </summary>
private void LoadGenericParameters(AGenericDeclaration <TNode> declaration)
{
var declarationType = declaration.GetData <Type>();
if (declarationType.IsGenericTypeDefinition)
{
var parameterSet = new List <IGenericParameterDeclaration>();
foreach (var parameter in declarationType.GetTypeInfo().GenericTypeParameters)
{
parameterSet.Add(new GenericParameterDeclaration(parameter.Name, null));
}
declaration.GenericParameters = parameterSet;
}
else
{
declaration.GenericParameters = Array.Empty <IGenericParameterDeclaration>();
}
}
