Added basic array support for UndefinedGenericType and fix related unit tests

Author: snakex64

src/NodeDev.Blazor/Components/GraphCanvas.razor.cs

@@ -413,7 +413,7 @@ private void OnNewNodeTypeSelected(NodeProvider.NodeSearchResult searchResult)
                 if (PopupNodeConnection.Type is UndefinedGenericType) // can connect to anything except exec
                     destination = destinations.FirstOrDefault(x => !x.Type.IsExec);
                 else // can connect to anything that is assignable to the type
-                    destination = destinations.FirstOrDefault(x => PopupNodeConnection.Type.IsAssignableTo(x.Type, out _) || (x.Type is UndefinedGenericType && !PopupNodeConnection.Type.IsExec));
+                    destination = destinations.FirstOrDefault(x => PopupNodeConnection.Type.IsAssignableTo(x.Type, out _, out _) || (x.Type is UndefinedGenericType && !PopupNodeConnection.Type.IsExec));
 
                 // if we found a connection, connect them together
                 if (destination != null)
@@ -459,9 +459,9 @@ private void OnNewOverloadSelected(Node.AlternateOverload overload)
     #region OnGenericTypeSelectionMenuAsked
 
     private bool IsShowingGenericTypeSelection = false;
-    private UndefinedGenericType? GenericTypeSelectionMenuGeneric;
+    private string? GenericTypeSelectionMenuGeneric;
 
-    public void OnGenericTypeSelectionMenuAsked(GraphNodeModel nodeModel, UndefinedGenericType undefinedGenericType)
+    public void OnGenericTypeSelectionMenuAsked(GraphNodeModel nodeModel, string undefinedGenericType)
     {
         PopupNode = nodeModel.Node;
         var p = Diagram.GetScreenPoint(nodeModel.Position.X, nodeModel.Position.Y) - Diagram.Container!.NorthWest;
@@ -478,7 +478,7 @@ private void OnGenericTypeSelected(TypeBase type)
         if (PopupNode == null || GenericTypeSelectionMenuGeneric == null)
             return;
 
-        GraphManagerService.PropagateNewGeneric(PopupNode, new Dictionary<UndefinedGenericType, TypeBase>() { [GenericTypeSelectionMenuGeneric] = type }, false, null, overrideInitialTypes: true);
+        GraphManagerService.PropagateNewGeneric(PopupNode, new Dictionary<string, TypeBase>() { [GenericTypeSelectionMenuGeneric] = type }, false, null, overrideInitialTypes: true);
 
         // Prefer updating the nodes directly instead of calling Graph.RaiseGraphChanged(true) to be sure it is called as soon as possible
         UpdateNodes(Graph.Nodes.Values.ToList());

src/NodeDev.Blazor/DiagramsModels/GraphNodeWidget.razor

@@ -16,7 +16,7 @@
 			<span class="ml-1">&lt;</span>
 			@foreach (var undefinedGeneric in undefinedGenerics)
 			{
-				<span class="ml-1 undefined-generic" @onclick="() => GraphCanvas.OnGenericTypeSelectionMenuAsked(Node, undefinedGeneric)">@(undefinedGeneric.Name + (undefinedGeneric == undefinedGenerics[^1] ? "" : ", "))</span>
+				<span class="ml-1 undefined-generic" @onclick="() => GraphCanvas.OnGenericTypeSelectionMenuAsked(Node, undefinedGeneric)">@(undefinedGeneric + (undefinedGeneric == undefinedGenerics[^1] ? "" : ", "))</span>
 			}
 			<span class="ml-1">&gt;</span>
 		}

src/NodeDev.Blazor/DiagramsModels/GraphPortModel.cs

@@ -29,6 +29,6 @@ public override bool CanAttachTo(ILinkable other)
         if(Alignment == otherPort.Alignment) // can't plug input to input or output to output
             return false;
 
-        return Connection.Type.IsAssignableTo(otherPort.Connection.Type, out _);
+        return Connection.Type.IsAssignableTo(otherPort.Connection.Type, out _, out _);
     }
 }

src/NodeDev.Blazor/Services/GraphManager/GraphManagerService.cs

@@ -24,10 +24,12 @@ public void AddNewConnectionBetween(Connection source, Connection destination)
         Graph.Connect(source, destination, false);
 
         // we're plugging something something with a generic into something without a generic
-        if (source.IsAssignableTo(destination, true, true, out var newTypes, out var usedInitialTypes) && newTypes.Count != 0)
+        if (source.IsAssignableTo(destination, true, true, out var newTypesLeft, out var newTypesRight, out var usedInitialTypes))
         {
-            PropagateNewGeneric(source.Parent, newTypes, usedInitialTypes, destination, false);
-            PropagateNewGeneric(destination.Parent, newTypes, usedInitialTypes, source, false);
+            if (newTypesLeft.Count != 0)
+                PropagateNewGeneric(source.Parent, newTypesLeft, usedInitialTypes, destination, false);
+            if (newTypesRight.Count != 0)
+                PropagateNewGeneric(destination.Parent, newTypesRight, usedInitialTypes, source, false);
         }
 
         GraphCanvas.UpdatePortColor(source);
@@ -55,7 +57,7 @@ public void DisconnectConnectionBetween(Connection source, Connection destinatio
     /// Propagate the new generic type to all the connections of the node and recursively to the connected nodes.
     /// </summary>
     /// <param name="initiatingConnection">The connection that initiated the propagation. This is used to avoid reupdating back and forth, sometimes erasing information in the process.</param>
-    public void PropagateNewGeneric(Node node, IReadOnlyDictionary<UndefinedGenericType, TypeBase> changedGenerics, bool useInitialTypes, Connection? initiatingConnection, bool overrideInitialTypes)
+    public void PropagateNewGeneric(Node node, IReadOnlyDictionary<string, TypeBase> changedGenerics, bool useInitialTypes, Connection? initiatingConnection, bool overrideInitialTypes)
     {
         bool hadAnyChanges = false;
         foreach (var port in node.InputsAndOutputs) // check if any of the ports have the generic we just solved
@@ -74,14 +76,19 @@ public void PropagateNewGeneric(Node node, IReadOnlyDictionary<UndefinedGenericT
                                             // check if other connections had their own generics and if we just solved them
             foreach (var other in port.Connections.ToList())
             {
-                if(other == initiatingConnection)
+                if (other == initiatingConnection)
                     continue;
 
                 var source = isPortInput ? other : port;
                 var target = isPortInput ? port : other;
-                if (source.IsAssignableTo(target, isPortInput, !isPortInput, out var changedGenerics2, out var usedInitialTypes) && changedGenerics2.Count != 0)
-                    PropagateNewGeneric(other.Parent, changedGenerics2, usedInitialTypes, port, false);
-                else if ((changedGenerics2?.Count ?? 0) != 0)// looks like changing the generic made it so we can't link to this connection anymore
+                if (source.IsAssignableTo(target, isPortInput, !isPortInput, out var changedGenericsLeft2, out var changedGenericsRight2, out var usedInitialTypes) && (changedGenericsLeft2.Count != 0 || changedGenericsRight2.Count != 0))
+                {
+                    if (changedGenericsLeft2.Count != 0)
+                        PropagateNewGeneric(port.Parent, changedGenericsLeft2, usedInitialTypes, other, false);
+                    if (changedGenericsRight2.Count != 0)
+                        PropagateNewGeneric(other.Parent, changedGenericsRight2, usedInitialTypes, port, false);
+                }
+                else if ((changedGenericsLeft2?.Count ?? 0) != 0)// looks like changing the generic made it so we can't link to this connection anymore
                     DisconnectConnectionBetween(port, other);
             }
         }

src/NodeDev.Core/Connections/Connection.cs

@@ -113,31 +113,33 @@ internal static Connection Deserialize(Node parent, SerializedConnection seriali
 
         #endregion
 
-        public bool IsAssignableTo(Connection other, bool alsoValidateInitialTypeSource, bool alsoValidateInitialTypeDestination, [MaybeNullWhen(false)] out Dictionary<UndefinedGenericType, TypeBase> changedGenerics, out bool usedInitialTypes)
+        public bool IsAssignableTo(Connection other, bool alsoValidateInitialTypeSource, bool alsoValidateInitialTypeDestination, [MaybeNullWhen(false)] out Dictionary<string, TypeBase> changedGenericsLeft, [MaybeNullWhen(false)] out Dictionary<string, TypeBase> changedGenericsRight, out bool usedInitialTypes)
         {
-            if (Type.IsAssignableTo(other.Type, out var changedGenerics1, out var depth1))
+            if (Type.IsAssignableTo(other.Type, out var changedGenericsLeft1, out var changedGenericsRight1, out var depth1))
             {
                 if (alsoValidateInitialTypeSource || alsoValidateInitialTypeDestination)
                 {
                     var initialType = alsoValidateInitialTypeSource ? InitialType : Type;
                     var otherInitialType = alsoValidateInitialTypeDestination ? other.InitialType : other.Type;
-                    if ((initialType != Type || otherInitialType != other.Type) && initialType.IsAssignableTo(otherInitialType, out var changedGenerics2, out var depth2))
+                    if ((initialType != Type || otherInitialType != other.Type) && initialType.IsAssignableTo(otherInitialType, out var changedGenericsLeft2, out var changedGenericsRight2, out var depth2))
                     {
-                        if (changedGenerics2.Count != 0 && depth2 < depth1)
+                        if ((changedGenericsLeft2.Count != 0 || changedGenericsRight2.Count != 0) && depth2 < depth1)
                         {
-                            changedGenerics = changedGenerics2;
+                            changedGenericsLeft = changedGenericsLeft2;
+                            changedGenericsRight = changedGenericsRight2;
                             usedInitialTypes = true;
                             return true;
                         }
                     }
                 }
 
-                changedGenerics = changedGenerics1;
+                changedGenericsLeft = changedGenericsLeft1;
+                changedGenericsRight = changedGenericsRight1;
                 usedInitialTypes = false;
                 return true;
             }
 
-            changedGenerics = null;
+            changedGenericsLeft = changedGenericsRight = null;
             usedInitialTypes = false;
             return false;
         }

src/NodeDev.Core/NodeProvider.cs

@@ -68,7 +68,7 @@ IEnumerable<NodeSearchResult> GetPropertiesAndFields(TypeBase type, string text)
 
                     // only keep the methods that are using the startConnection type, if provided
                     if (startConnection?.Type?.IsExec == false)
-                        methods = methods.Where(x => x.GetParameters().Any(y => startConnection.Type.IsAssignableTo(y.ParameterType, out _)));
+                        methods = methods.Where(x => x.GetParameters().Any(y => startConnection.Type.IsAssignableTo(y.ParameterType, out _, out _)));
 
                     results = results.Concat(methods.Select(x => new MethodCallNode(typeof(MethodCall), x)));
 
@@ -123,7 +123,7 @@ private static IEnumerable<IMethodInfo> GetExtensionMethods(TypeBase t, TypeFact
                         .GetTypes()
                         .Where(type => !type.IsGenericType)
                         .SelectMany(x => x.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
-                        .Where(method => method.IsDefined(typeof(ExtensionAttribute), false) && t.IsAssignableTo(typeFactory.Get(method.GetParameters()[0].ParameterType, null), out _))
+                        .Where(method => method.IsDefined(typeof(ExtensionAttribute), false) && t.IsAssignableTo(typeFactory.Get(method.GetParameters()[0].ParameterType, null), out _, out _))
                         .Select(x => new RealMethodInfo(typeFactory, x, typeFactory.Get(x.DeclaringType!, null)))
                         .ToList();
                 });

src/NodeDev.Core/Nodes/Node.cs

@@ -61,7 +61,7 @@ public Node(Graph graph, string? id = null)
 		/// </summary>
 		public int GraphIndex { get; set; } = -1;
 
-		public IEnumerable<UndefinedGenericType> GetUndefinedGenericTypes() => InputsAndOutputs.SelectMany(x => x.Type.GetUndefinedGenericTypes()).Distinct();
+		public IEnumerable<string> GetUndefinedGenericTypes() => InputsAndOutputs.SelectMany(x => x.Type.GetUndefinedGenericTypes()).Distinct();
 
 		public record class AlternateOverload(TypeBase ReturnType, List<IMethodParameterInfo> Parameters);
 		public virtual IEnumerable<AlternateOverload> AlternatesOverloads => [];

src/NodeDev.Core/Types/NodeClassArrayType.cs

@@ -95,6 +95,9 @@ protected internal override string Serialize()
 
         public static string GetArrayString(int nbArrayLevels)
         {
+            if (nbArrayLevels == 0)
+                return string.Empty;
+
             var str = string.Create(nbArrayLevels * 2, nbArrayLevels, static (span, nbLevels) =>
             {
                 for (int i = 0; i < span.Length; i += 2)