Features/assotiation with nullable types

README.md

@@ -380,7 +380,10 @@ If you specify the "createAssociation" option, object associations is created fr
 
 ```cs
 class ClassA{
+    // With primitive types, does not create association (for readability)
     public IList<string> Strings{get;} = new List<string>();
+    // With reference types, it does create an association
+    public IList<Type1> ListOfType1{get;} = new List<Type1>();
     public Type1 Prop1{get;set;}
     public Type2 field1;
 }
@@ -400,23 +403,22 @@ class Type2{
 ```
 @startuml
 class ClassA {
+    + Strings : IList<string>
 }
 class Type1 {
     + value1 : int <<get>> <<set>>
 }
 class Type2 {
     + string1 : string <<get>> <<set>>
 }
-class "IList`1"<T> {
-}
-ClassA o-> "Strings<string>" "IList`1"
+ClassA o-> "ListOfType1" Type1
 ClassA --> "Prop1" Type1
 ClassA --> "field1" Type2
 Type2 --> "Prop2" ExternalType
 @enduml
 ```
 
-![InheritanceRelationsips.png](uml/Associations.png)
+![Associations.png](uml/Associations.png)
 
 
 ### Record types (with parameter list)
@@ -680,10 +682,8 @@ class ClassB {
     + Users : IList<User> <<get>>
     + ClassB(users:IList<User>)
 }
-class "IList`1"<T> {
-}
 ClassA --> "DefaultUser" User
-ClassA --> "Users<User>" "IList`1"
+ClassA --> "Users" User
 @enduml
 ```
 

src/PlantUmlClassDiagramGenerator.Library/ClassDiagramGenerator.cs

@@ -206,6 +206,28 @@ public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
         var modifiers = GetMemberModifiersText(node.Modifiers,
                 isInterfaceMember: node.Parent.IsKind(SyntaxKind.InterfaceDeclaration));
         var type = node.Declaration.Type;
+        var isGeneric = false;
+        IEnumerable<SyntaxNode> argumentTypesNodes;
+        var isArray = false;
+
+        var embededType = type is NullableTypeSyntax nullableTypeSyntax ? nullableTypeSyntax.ElementType : type;
+
+        if (embededType is GenericNameSyntax genericNameSyntax)
+        {
+            isGeneric = true;
+            argumentTypesNodes = genericNameSyntax.TypeArgumentList.Arguments;
+        }
+        else
+        {
+            argumentTypesNodes = new List<TypeSyntax>();
+        }
+
+        if (embededType is ArrayTypeSyntax arrayTypeSyntax)
+        {
+            isArray = true;
+            argumentTypesNodes = [arrayTypeSyntax.ElementType];
+        }
+
         var variables = node.Declaration.Variables;
         var parentClass = (node.Parent as TypeDeclarationSyntax);
         var isTypeParameterField = parentClass?.TypeParameterList?.Parameters
@@ -223,7 +245,9 @@ public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
             else if (!createAssociation
                 || node.AttributeLists.HasIgnoreAssociationAttribute()
                 || fieldType == typeof(PredefinedTypeSyntax)
-                || fieldType == typeof(NullableTypeSyntax)
+                || (fieldType == typeof(NullableTypeSyntax) && !isGeneric && !isArray)
+                || (isGeneric && argumentTypesNodes.FirstOrDefault() is PredefinedTypeSyntax)
+                || (isArray && argumentTypesNodes.FirstOrDefault() is PredefinedTypeSyntax)
                 || isTypeParameterField)
             {
                 var useLiteralInit = field.Initializer?.Value?.Kind().ToString().EndsWith("LiteralExpression") ?? false;
@@ -235,10 +259,6 @@ public override void VisitFieldDeclaration(FieldDeclarationSyntax node)
             }
             else
             {
-                if (fieldType == typeof(GenericNameSyntax))
-                {
-                    additionalTypeDeclarationNodes.Add(type);
-                }
                 relationships.AddAssociationFrom(node, field);
             }
         }

src/PlantUmlClassDiagramGenerator.Library/RelationshipCollection.cs

@@ -1,5 +1,6 @@
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using PlantUmlClassDiagramGenerator.Attributes;
@@ -36,12 +37,44 @@ public void AddInnerclassRelationFrom(SyntaxNode node)
 
     public void AddAssociationFrom(FieldDeclarationSyntax node, VariableDeclaratorSyntax field)
     {
-        if (node.Declaration.Type is not SimpleNameSyntax leafNode 
+        // Just ignore the nullability of the node
+        var realDeclarationType = node.Declaration.Type is NullableTypeSyntax nullableTypeSyntax ? nullableTypeSyntax.ElementType : node.Declaration.Type;
+
+        if ((realDeclarationType is not IdentifierNameSyntax && realDeclarationType is not GenericNameSyntax && realDeclarationType is not ArrayTypeSyntax)
             || node.Parent is not BaseTypeDeclarationSyntax rootNode) return;
 
+        TypeNameText typeNameText = null;
+
+        if(realDeclarationType is IdentifierNameSyntax identifierNameSyntax)
+        {
+            typeNameText = TypeNameText.From(identifierNameSyntax as SimpleNameSyntax); 
+        }
+
+        if(realDeclarationType is GenericNameSyntax genericNameSyntax)
+        {
+            var childNode = genericNameSyntax.TypeArgumentList.ChildNodes().FirstOrDefault();
+            if(childNode is SimpleNameSyntax simpleNameSyntax)
+            {
+                typeNameText = TypeNameText.From(simpleNameSyntax);
+            }
+
+            if(childNode is PredefinedTypeSyntax predefinedTypeSyntax)
+            {
+                typeNameText = TypeNameText.From(predefinedTypeSyntax);
+            }
+        }
+
+        if(realDeclarationType is ArrayTypeSyntax arrayTypeSyntax)
+        {
+            if(arrayTypeSyntax.ElementType is SimpleNameSyntax simpleNameSyntax)
+            {
+                typeNameText = TypeNameText.From(simpleNameSyntax);
+            }
+        }
+
         var symbol = field.Initializer == null ? "-->" : "o->";
         var fieldIdentifier = field.Identifier.ToString();
-        var leafName = TypeNameText.From(leafNode);
+        var leafName = typeNameText;
         var rootName = TypeNameText.From(rootNode);
         AddRelationship(leafName, rootName, symbol, fieldIdentifier);
     }

src/PlantUmlClassDiagramGenerator.Library/TypeNameText.cs

@@ -8,6 +8,16 @@ public class TypeNameText
 
     public string TypeArguments { get; set; }
 
+    public static TypeNameText From(PredefinedTypeSyntax syntax)
+    {
+
+        return new TypeNameText
+        {
+            Identifier = syntax.Keyword.ValueText,
+            TypeArguments = string.Empty
+        };
+    }
+
     public static TypeNameText From(SimpleNameSyntax syntax)
     {
         var identifier = syntax.Identifier.Text;

src/PlantUmlClassDiagramGenerator/PlantUmlClassDiagramGenerator.csproj

@@ -12,11 +12,15 @@
 		<RepositoryType></RepositoryType>
 		<PackageTags>plantuml</PackageTags>
 		<GeneratePackageOnBuild>true</GeneratePackageOnBuild>
-		<Version>1.3.4</Version>
+		<Version>1.4.0</Version>
 		<Authors>pierre3</Authors>
 		<Company />
 		<Product />
 		<PackageReleaseNotes>
+			[V1.4.0]
+			- Migated to .net 8.0
+			- Fixed the association not targeting the associated type
+			- Fixed the associations on nullable types
 			[V1.3.4]
 			- Added support for the "struct" keyword in type definitions.
 			- Added exclude path to consider "**/" syntax (filtering on all folder levels).