Refactor and enhance error handling in ListFunctions

- Added new using directives and removed duplicates in ConvertToDictionaryCmdlet.cs.
- Improved KeyComparer condition and introduced nullable dictType for better type handling.
- Enhanced error handling with ListFunctionsException to provide more context on failures.
- Updated ValidateScriptVariableAttribute.cs to use HashSet<string> for better performance and null handling.
- Introduced ObjectExtensions class in ObjectExtensions.cs for cloning functionality.

Author: Yevrag35

src/engine/ListFunctions-Next/Cmdlets/Constructs/ConvertToDictionaryCmdlet.cs

@@ -1,4 +1,5 @@
-using ListFunctions.Extensions;
+using ListFunctions.Exceptions;
+using ListFunctions.Extensions;
 using ListFunctions.Modern;
 using ListFunctions.Modern.Variables;
 using ListFunctions.Validation;
@@ -119,29 +120,33 @@ private IDictionary CreateDictionary(object?[] inputObjects)
                 _valueType = this.GetValueType(_valueType, inputObjects);
             }
 
-            if (this.KeyComparer is null && (_keyType.Equals(typeof(string))))
+            if (this.KeyComparer is null && _keyType.Equals(typeof(string)))
             {
                 this.KeyComparer = StringComparer.OrdinalIgnoreCase;
             }
 
             object[] args = this.KeyComparer is null
                 ? Array.Empty<object>()
                 : new object[] { this.KeyComparer };
-            
+
+            Type? dictType = null;
             try
             {
-                Type dictType = typeof(Dictionary<,>).MakeGenericType(_keyType, _valueType);
+                dictType = typeof(Dictionary<,>).MakeGenericType(_keyType, _valueType);
                 return Activator.CreateInstance(dictType, args) as IDictionary
                     ?? throw new InvalidOperationException("Somehow, Dictionary is not an IDictionary?");
             }
             catch (Exception e)
             {
-                var rec = e.ToRecord(ErrorCategory.InvalidOperation, new Dictionary<string, object?>(3, StringComparer.OrdinalIgnoreCase)
-                {
-                    { nameof(InputObject), inputObjects },
-                    { "KeyType", _keyType },
-                    { "ValueType", _valueType },
-                });
+                ListFunctionsException ex = new($"Failed to instantiate dictionary with the arguments supplied - {e.Message}", e);
+                IDictionary data = ex.Data;
+                data["KeyType"] = _keyType;
+                data[nameof(InputObject)] = inputObjects.DeepClone();
+                data[nameof(ValueType)] = _valueType;
+                data["DictionaryType"] = dictType;
+
+                var rec = ex.ToRecord(ErrorCategory.InvalidOperation, targetObj: null);
+                
                 this.ThrowTerminatingError(rec);
                 throw;
             }

src/engine/ListFunctions-Next/Validation/ValidateScriptVariableAttribute.cs

@@ -121,8 +121,8 @@ private static bool IsAllValid(ScriptBlock block, HashSet<string>? mustContainNa
                 : block.Ast.FindAll(searchNestedScriptBlocks: false, predicate: IsVariableAst);
 
             return allowsArgs
-                ? IsValidWithIndexes(asts, mustContainNames, mustContainIndexes)
-                : IsValidNoIndexes(asts, mustContainNames, mustContainIndexes);
+                ? IsValidWithIndexes(asts, mustContainNames, mustContainIndexes!)
+                : IsValidNoIndexes(asts, mustContainNames!);
         }
 
         private static bool IsVariableAst(Ast ast)
@@ -141,32 +141,30 @@ private static bool IsArgsIndexed(Ast ast)
                 && Args.Equals(varAst.VariablePath.UserPath, StringComparison.OrdinalIgnoreCase);
         }
 
-        private static bool IsValidWithIndexes(IEnumerable<Ast> asts, ICollection<string>? anyNames, HashSet<int>? orAnyIndexes)
+        private static bool IsValidWithIndexes(IEnumerable<Ast> asts, HashSet<string>? anyNames, HashSet<int> orAnyIndexes)
         {
-            if (anyNames is null) anyNames = Array.Empty<string>();
-
+            bool isNotNull = !(anyNames is null || anyNames.Count == 0);
             foreach (Ast ast in asts.AsValueEnumerable())
             {
-                if (ast is VariableExpressionAst varAst && anyNames.Contains(varAst.VariablePath.UserPath))
+                if (ast is VariableExpressionAst varAst && isNotNull && anyNames!.Contains(varAst.VariablePath.UserPath))
                 {
                     return true;
                 }
                 else if (ast is IndexExpressionAst indexAst && indexAst.Index is ConstantExpressionAst constAst && constAst.Value is int index
                     &&
-                    orAnyIndexes!.Contains(index))
+                    orAnyIndexes.Contains(index))
                 {
                     return true;
                 }
             }
 
             return false;
         }
-        private static bool IsValidNoIndexes(IEnumerable<Ast> asts, ICollection<string>? anyNames, HashSet<int>? _)
+        private static bool IsValidNoIndexes(IEnumerable<Ast> asts, HashSet<string> anyNames)
         {
-            Debug.Assert(!(anyNames is null), "Names should not null here.");
             foreach (VariableExpressionAst varAst in asts.AsValueEnumerable())
             {
-                if (anyNames!.Contains(varAst.VariablePath.UserPath))
+                if (anyNames.Contains(varAst.VariablePath.UserPath))
                 {
                     return true;
                 }

src/engine/ListFunctions.Engine/Exceptions/ListFunctionsException.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace ListFunctions.Exceptions
+{
+    public class ListFunctionsException : Exception
+    {
+        public ListFunctionsException(string message, Exception? innerException)
+            : base(message, innerException)
+        {
+        }
+    }
+}
+

src/engine/ListFunctions.Engine/Extensions/ObjectExtensions.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Management.Automation;
+using System.Reflection;
+using System.Text;
+
+#nullable enable
+
+namespace ListFunctions.Extensions
+{
+    public static class ObjectExtensions
+    {
+        [return: NotNullIfNotNull(nameof(obj))]
+        internal static object? CloneIf(this object? obj)
+        {
+            if (obj is ICloneable cloneable)
+            {
+                return cloneable.Clone();
+            }
+            else if (obj is PSObject pso)
+            {
+                return pso.Copy();
+            }
+            else if (obj is PSCustomObject customObj)
+            {
+                return PSObject.AsPSObject(customObj).Copy();
+            }
+            else if (obj is PSMemberInfo member)
+            {
+                return member.Copy();
+            }
+            else
+            {
+                return obj;
+            }
+        }
+
+        public static object?[] DeepClone(this object?[]? source)
+        {
+            if (source is null || source.Length == 0)
+                return Array.Empty<object>();
+
+            return Array.ConvertAll(source, CloneIf);
+        }
+    }
+}
+