/// <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);