public void LoadClassAttributes()
{
var type = typeof(AttributedClass);
var declaration = DeclarationHelper.CreateDeclarationFactory(this.testOutputHelper)
.CreateClassDeclaration(type);
Assert.NotNull(declaration);
Assert.Equal(
ReflectionGenericDeclarationLoader <SyntaxNode> .GetNameWithoutGeneric(type.Name),
declaration.Name);
var classDeclaration = Assert.IsType <ClassDeclaration>(declaration);
var declarationResolverMock = new Mock <IDeclarationResolver>();
classDeclaration.Load(declarationResolverMock.Object);
Assert.NotNull(declaration.Attributes);
var attribute = Assert.Single(declaration.Attributes);
Assert.Equal(nameof(PatternAttribute), attribute.Name);
Assert.NotNull(attribute.SyntaxNodeProvider);
var node = attribute.SyntaxNodeProvider.SyntaxNode;
Assert.NotNull(node);
var attrText = node.ToString();
Assert.Contains(nameof(PatternAttribute), attrText, StringComparison.OrdinalIgnoreCase);
}
public void PredefinedTypeDeclarationUseTest(Type type, string typeName)
{
var resolverMock = new Mock <IDeclarationResolver>();
var use = ReflectionGenericDeclarationLoader <SyntaxNode> .GetDeclarationUseFrom(type, resolverMock.Object);
Assert.NotNull(use);
Assert.NotNull(use.Declaration);
var pdu = Assert.IsType <PredefinedDeclarationUse>(use);
Assert.Equal(typeName, pdu.Declaration.Name);
}
public void UnknownTypeDeclarationUseTest()
{
var type = typeof(List <object>);
var resolverMock = new Mock <IDeclarationResolver>();
var use = ReflectionGenericDeclarationLoader <SyntaxNode> .GetDeclarationUseFrom(type, resolverMock.Object);
Assert.NotNull(use);
Assert.NotNull(use.Declaration);
var udu = Assert.IsType <UnknownDeclarationUse>(use);
Assert.Equal(ReflectionGenericDeclarationLoader <SyntaxNode> .GetNameWithoutGeneric(type.Name), udu.Declaration.Name);
}
/// <inheritdoc/>
public IClassDeclaration CreateClassDeclaration(Type type)
{
var decl = new ClassDeclaration(
type.Namespace,
ReflectionGenericDeclarationLoader <SyntaxNode> .GetNameWithoutGeneric(type.Name),
new ReflectionTypeSyntaxNodeProvider <ClassDeclarationSyntax>(type),
null,
type.Assembly.Location,
this.reflectionLoaderClassDeclarationSyntax);
this.reflectionLoaderClassDeclarationSyntax.Setup(decl, type);
return(decl);
}
public DeclarationFactory(
ReflectionGenericDeclarationLoader <InterfaceDeclarationSyntax> reflectionLoaderInterfaceDeclarationSyntax,
ReflectionGenericDeclarationLoader <ClassDeclarationSyntax> reflectionLoaderClassDeclarationSyntax,
ParserGenericDeclarationLoader <InterfaceDeclarationSyntax> parserLoaderInterfaceDeclarationSyntax,
ParserGenericDeclarationLoader <ClassDeclarationSyntax> parserLoaderClassDeclarationSyntax,
ParserGenericDeclarationLoader <StructDeclarationSyntax> parserLoaderStructDeclarationSyntax)
{
this.reflectionLoaderInterfaceDeclarationSyntax = reflectionLoaderInterfaceDeclarationSyntax;
this.reflectionLoaderClassDeclarationSyntax = reflectionLoaderClassDeclarationSyntax;
this.parserLoaderInterfaceDeclarationSyntax = parserLoaderInterfaceDeclarationSyntax;
this.parserLoaderClassDeclarationSyntax = parserLoaderClassDeclarationSyntax;
this.parserLoaderStructDeclarationSyntax = parserLoaderStructDeclarationSyntax;
}
public void ResolvedTypeDeclarationUseTest()
{
var type = typeof(TypeGenericDeclarationUseTest);
var resolvedDeclaration = Mock.Of <IGenericDeclaration <SyntaxNode> >();
var resolverMock = new Mock <IDeclarationResolver>();
resolverMock.Setup(r => r.Resolve(type)).Returns(resolvedDeclaration);
var use = ReflectionGenericDeclarationLoader <SyntaxNode> .GetDeclarationUseFrom(type, resolverMock.Object);
Assert.NotNull(use);
Assert.NotNull(use.Declaration);
var gdu = Assert.IsType <GenericDeclarationUse>(use);
Assert.Same(resolvedDeclaration, gdu.Declaration);
}
public void BasicReflectionLoadingTest(Type type)
{
var declaration = DeclarationHelper.CreateDeclarationFactory(this.testOutputHelper)
.CreateClassDeclaration(type);
Assert.NotNull(declaration);
Assert.Equal(
ReflectionGenericDeclarationLoader <SyntaxNode> .GetNameWithoutGeneric(type.Name),
declaration.Name);
Assert.NotNull(declaration.SyntaxNodeProvider);
Assert.NotNull(declaration.SyntaxNodeProvider.SyntaxNode);
Assert.Null(declaration.GenericParameters);
Assert.Null(declaration.Extends);
Assert.Null(declaration.Members);
var classDeclaration = Assert.IsType <ClassDeclaration>(declaration);
var declarationResolverMock = new Mock <IDeclarationResolver>();
classDeclaration.Load(declarationResolverMock.Object);
Assert.NotNull(declaration.GenericParameters);
Assert.NotNull(declaration.Extends);
Assert.NotNull(declaration.Members);
if (type.IsGenericTypeDefinition)
{
Assert.NotEmpty(declaration.GenericParameters);
var typeParams = type.GetTypeInfo().GenericTypeParameters;
Assert.Equal(typeParams.Length, declaration.GenericParameters.Count);
Assert.Equal(typeParams[0].Name, declaration.GenericParameters.First().Name);
}
else
{
Assert.Empty(declaration.GenericParameters);
}
}
/// <inheritdoc/>
public IGenericDeclaration <SyntaxNode> Resolve(Type type)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type), $"The argument {nameof(type)} was null.");
}
var fullName = type.FullName;
if (fullName == null)
{
return(null);
}
fullName = ReflectionGenericDeclarationLoader <SyntaxNode> .GetNameWithoutGeneric(fullName);
var declarations = this.FindDeclarations(fullName, null);
if (declarations != null)
{
var tParamCount = type.GetTypeInfo().GenericTypeParameters.Length;
foreach (var declarationItem in declarations)
{
// Make sure the declaration is loaded
this.loader(this, declarationItem);
if (declarationItem is IGenericDeclaration <SyntaxNode> gd && tParamCount == gd.GenericParameters.Count)
{
// TODO take into account the type parameter constraints.
return(gd);
}
}
}
return(null);
}
