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