/// <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)
{
BaseListSyntax baseListSyntax = BaseListGetter(declaration.SyntaxNodeProvider.SyntaxNode);
if (baseListSyntax != null)
{
var baseWalker = new DeclarationUseWalker(resolver, declaration);
var uses = new List <IDeclarationUse <SyntaxNode> >();
foreach (var node in baseListSyntax.ChildNodes())
{
var use = baseWalker.Visit(node);
if (use.Declaration is IGenericDeclarationImpl genericDeclaration)
{
genericDeclaration.AddExtendedBy(declaration);
}
uses.Add(use);
}
declaration.Extends = uses;
}
else
{
declaration.Extends = Array.Empty <IDeclarationUse <SyntaxNode> >();
}
}
/// <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> >();
}
}
internal override void Load(AGenericDeclaration <TNode> declaration, IDeclarationResolver resolver)
{
this.LoadGenericParameters(declaration);
this.LoadExtends(declaration, resolver);
this.LoadMembers(declaration, resolver);
this.LoadAttributes(declaration, resolver);
}
private void LoadAttributes(AGenericDeclaration <TNode> declaration, IDeclarationResolver resolver)
{
var attributeList = new List <IAttributeUse>();
var attributesWalker = new AttributesWalker(resolver, declaration, attributeList);
attributesWalker.Visit(declaration.SyntaxNodeProvider.SyntaxNode);
declaration.Attributes = attributeList.Any() ? attributeList.ToArray() : Array.Empty <IAttributeUse>();
}
/// <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> >();
var membersWalker = new MembersWalker(resolver, declaration, memberList);
membersWalker.Visit(declaration.SyntaxNodeProvider.SyntaxNode);
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 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> >();
}
/// <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>();
}
}
/// <summary>
/// Load the generic parameters from the type parameter list node.
/// </summary>
private void LoadGenericParameters(AGenericDeclaration <TNode> declaration)
{
var parameterList = TypeParameterListGetter(declaration.SyntaxNodeProvider.SyntaxNode);
if (parameterList != null)
{
var parameterSet = new List <IGenericParameterDeclaration>();
foreach (var parameter in parameterList.Parameters)
{
parameterSet.Add(new GenericParameterDeclaration(
parameter.Identifier.Text,
new ParserSyntaxNodeProvider <TypeParameterSyntax>(parameter)));
}
declaration.GenericParameters = parameterSet;
}
else
{
declaration.GenericParameters = Array.Empty <IGenericParameterDeclaration>();
}
}
internal override ISyntaxNodeProvider <TypeParameterListSyntax> GetTypeParameterListSyntaxProvider(
AGenericDeclaration <TNode> declaration)
{
return(new ParserSyntaxNodeProvider <TypeParameterListSyntax>(
TypeParameterListGetter(declaration.SyntaxNodeProvider.SyntaxNode)));
}
/// <summary>
/// Setup the given declaration to be loaded by reflection from the given type.
/// </summary>
/// <param name="decl">The declaration that will be loaded.</param>
/// <param name="type">The type to load the declaration from.</param>
internal void Setup(AGenericDeclaration <TNode> decl, Type type)
{
decl.SetData(type);
}
internal override ISyntaxNodeProvider <TypeParameterListSyntax> GetTypeParameterListSyntaxProvider(
AGenericDeclaration <TNode> declaration)
{
throw new NotImplementedException();
}
/// <summary> /// Get the TypeParameterListSyntaxProvider for the given. /// </summary> /// <param name="declaration">The generic declaration to load.</param> /// <returns>The TypeParameterListSyntaxProvider.</returns> internal abstract ISyntaxNodeProvider <TypeParameterListSyntax> GetTypeParameterListSyntaxProvider(AGenericDeclaration <TNode> declaration);
/// <summary> /// Load the given declaration. /// </summary> /// <param name="declaration">The generic declaration to load.</param> /// <param name="resolver">The declaration resolver.</param> internal abstract void Load(AGenericDeclaration <TNode> declaration, IDeclarationResolver resolver);
