/// <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); }
/// <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> >(); } }
internal static IDeclarationUse <SyntaxNode> GetDeclarationUseFrom( Type type, IDeclarationResolver resolver, int arrayCount = 0) { if (type.IsArray) { var eltType = type.GetElementType(); return(GetDeclarationUseFrom(eltType, resolver, arrayCount + 1)); } if (TryGetPredefinedDeclarationUse(type, out var typeUse)) { typeUse.ArraySpecification = CreateArraySpecification( arrayCount, typeUse.SyntaxNodeProvider); return(typeUse); } var interfaceDeclaration = resolver.Resolve(type); if (interfaceDeclaration == null) { var unknownDeclarationUse = new UnknownDeclarationUse( new ReflectionTypeUseSyntaxNodeProvider <IdentifierNameSyntax>(type), new UnknownDeclaration(GetNameWithoutGeneric(type.Name))); unknownDeclarationUse.ArraySpecification = CreateArraySpecification( arrayCount, unknownDeclarationUse.SyntaxNodeProvider); return(unknownDeclarationUse); } IReadOnlyCollection <IDeclarationUse <SyntaxNode> > genericParameters; if (type.IsGenericType) { var uses = new List <IDeclarationUse <SyntaxNode> >(); foreach (var typeArg in type.GenericTypeArguments) { uses.Add(GetDeclarationUseFrom(typeArg, resolver)); } genericParameters = uses; } else { genericParameters = Array.Empty <IDeclarationUse <SyntaxNode> >(); } var genericDeclarationUse = new GenericDeclarationUse( new ReflectionTypeUseSyntaxNodeProvider <SimpleNameSyntax>(type), interfaceDeclaration, genericParameters); genericDeclarationUse.ArraySpecification = CreateArraySpecification( arrayCount, genericDeclarationUse.SyntaxNodeProvider); return(genericDeclarationUse); }
/// <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> >(); }
public MembersWalker( IDeclarationResolver resolver, IGenericDeclaration <SyntaxNode> genericDeclaration, List <IMemberDeclaration <SyntaxNode> > memberList) { this.resolver = resolver; this.memberList = memberList; this.genericDeclaration = genericDeclaration; }
public AttributesWalker( IDeclarationResolver resolver, IGenericDeclaration <SyntaxNode> genericDeclaration, List <IAttributeUse> attributesList) { this.resolver = resolver; this.attributesList = attributesList; this.genericDeclaration = genericDeclaration; }
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>(); }
/// <inheritdoc/> public void Load(IDeclarationResolver resolver, IDeclaration <SyntaxNode> declaration) { if (declaration == null) { throw new ArgumentNullException(nameof(declaration), $"The argument {nameof(declaration)} was null."); } ((ADeclaration)declaration).Load(resolver); }
/// <summary> /// Load the declaration. /// </summary> /// <param name="resolver">The resolver to resolve dependencies.</param> public void Load(IDeclarationResolver resolver) { if (this.isLoaded) { return; } this.isLoaded = true; this.LoadImpl(resolver); }
public AutomatedGenericStrategy( IGenericDeclaration <SyntaxNode> pattern, IGenericDeclaration <SyntaxNode> declaration, IDeclarationResolver resolver) { this.declaration = declaration; this.pattern = pattern; this.resolver = resolver; this.targetDeclarationName = GeneratorHelper.ComputeClassName(declaration.Name); this.targetPatternName = GeneratorHelper.ComputeClassName(pattern.Name); }
public AutomatedDeclarationsStrategy( IDeclaration <SyntaxNode> pattern, string nameSpace, string name, IEnumerable <IDeclaration <SyntaxNode> > declarations, IDeclarationResolver resolver) { this.targetName = name; this.currentNameSpace = nameSpace; this.declarations = declarations; this.pattern = pattern; this.resolver = resolver; }
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> /// Initializes a new instance of the <see cref="AutomatedGenerator"/> class. /// </summary> /// <param name="generator">The generator to use to generate the output.</param> /// <param name="locator">Code generation locator.</param> /// <param name="resolver">The resolver to resolve workspace symbols.</param> /// <param name="patternType">The pattern type to use.</param> public AutomatedGenerator(IGenerator generator, ILocator locator, IDeclarationResolver resolver, Type patternType) { if (generator == null) { throw new ArgumentNullException(nameof(generator)); } if (locator == null) { throw new ArgumentNullException(nameof(locator)); } if (resolver == null) { throw new ArgumentNullException(nameof(resolver)); } if (patternType == null) { throw new ArgumentNullException(nameof(patternType)); } this.generator = generator; this.resolver = resolver; this.locator = locator; this.patternType = patternType; this.patternAttribute = FindAttribute <PatternAttribute>(this.patternType); // Get the pattern as source declaration from the given resolver. var factoryPatternItfDecl = resolver .Find(patternType.FullName) .Single(); this.pattern = factoryPatternItfDecl; }
public DeclarationUseWalker(IDeclarationResolver resolver, IGenericDeclaration <SyntaxNode> genericDeclaration) { this.resolver = resolver; this.genericDeclaration = genericDeclaration; }
/// <inheritdoc/> protected override void LoadImpl(IDeclarationResolver resolver) { this.loader.Load(this, resolver); }
/// <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);
/// <inheritdoc/> protected override void LoadImpl(IDeclarationResolver resolver) { // Nothing to do. }
/// <summary> /// Implementation of the declaration loading. /// </summary> /// <param name="resolver">The resolver to resolve dependencies.</param> protected abstract void LoadImpl(IDeclarationResolver resolver);