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