feat(literal-types): including all literal types for non-navigation/simple members

LogicBuilder.Expressions.Utils.Tests/TypeExtensionsTests.cs

@@ -46,9 +46,9 @@ public void GetSelectedMembers_WhenSelectIsEmpty_MustReturnAllLiteralAndLiteralL
             Assert.Multiple(() =>
             {
                 var names = memberInfos.Select(mi => mi.Name).ToList();
-                
+
                 Assert.DoesNotContain(memberInfos, name => name.Name == nameof(Thing.Objects));
-                
+
                 Assert.Contains(names, name => name == nameof(Thing.ParametersArray));
                 Assert.Contains(names, name => name == nameof(Thing.ParametersList));
                 Assert.Contains(names, name => name == nameof(Thing.Ints));
@@ -64,6 +64,30 @@ public void GetSelectedMembers_WhenSelectIsEmpty_MustReturnAllLiteralAndLiteralL
             });
         }
 
+        [Fact]
+        public void GetSelectedMembers_WhenSelectIsEmpty_MustReturnAllLiteralAndLiteralDictionaries()
+        {
+            // Act
+            var memberInfos = typeof(Dictionaries).GetSelectedMembers(Enumerable.Empty<string>().ToList());
+
+            // Assert
+            Assert.Multiple(() =>
+            {
+                var names = memberInfos.Select(mi => mi.Name).ToList();
+
+                Assert.DoesNotContain(memberInfos, name => name.Name == nameof(Dictionaries.ObjectDictionary));
+
+                Assert.Contains(names, name => name == nameof(Dictionaries.InnerDictionary));
+                Assert.Contains(names, name => name == nameof(Dictionaries.InnerDictionary2));
+                Assert.Contains(names, name => name == nameof(Dictionaries.ListIntStringDictionary));
+                Assert.Contains(names, name => name == nameof(Dictionaries.IntStringDictionary));
+                Assert.Contains(names, name => name == nameof(Dictionaries.ListStringDictionary));
+                Assert.Contains(names, name => name == nameof(Dictionaries.ListOfDictionaries));
+                Assert.Contains(names, name => name == nameof(Dictionaries.ArrayOfDictionaries));
+                Assert.Contains(names, name => name == nameof(Dictionaries.ArrayOfLookups));
+            });
+        }
+
         private abstract class BaseThing
         {
             public string Name { get; set; }
@@ -97,5 +121,18 @@ private class Thing
             public IEnumerable<int> Ints { get; set; }
             public List<object> Objects { get; set; }
         }
+
+        private sealed class Dictionaries
+        {
+            public Dictionary<int, string> IntStringDictionary { get; set; }
+            public Dictionary<List<int>, string> ListIntStringDictionary { get; set; }
+            public Dictionary<string, List<string>> ListStringDictionary { get; set; }
+            public Dictionary<Dictionary<string, int>, List<string>> InnerDictionary { get; set; }
+            public Dictionary<List<string>, Dictionary<string, int>> InnerDictionary2 { get; set; }
+            public Dictionary<List<object>, Dictionary<string, int>> ObjectDictionary { get; set; }
+            public List<Dictionary<List<int>, string[]>> ListOfDictionaries { get; set; }
+            public Dictionary<int, string>[] ArrayOfDictionaries { get; set; }
+            public Lookup<int, string>[] ArrayOfLookups { get; set; }
+        }
     }
 }

LogicBuilder.Expressions.Utils/TypeExtensions.cs

@@ -204,12 +204,21 @@ private static MemberInfo[] GetValueTypeMembers(this Type parentType)
             return parentType.GetMemberInfos().Where
             (
                 info => (info.MemberType == MemberTypes.Field || info.MemberType == MemberTypes.Property)
-                && (info.GetMemberType().IsLiteralType() || info.GetMemberType().IsLiteralList())
+                && info.GetMemberType().AllUnderlyingTypesLiteral()
             ).ToArray();
         }
 
-        private static bool IsLiteralList(this Type type) 
-            => type.IsList() && type.GetUnderlyingElementType().IsLiteralType();
+        private static bool AllUnderlyingTypesLiteral(this Type type) =>
+            type.UnderlyingElementTypes().All(t => t.IsLiteralType());
+
+        private static IEnumerable<Type> UnderlyingElementTypes(this Type type)
+        {
+            if (type.IsArray) return type.GetElementType().UnderlyingElementTypes();
+
+            return type.IsGenericType
+                ? type.GetGenericArguments().SelectMany(t => t.UnderlyingElementTypes()) 
+                : new[] { type };
+        }
 
         private static MemberInfo[] GetMemberInfos(this Type parentType) 
             => parentType.GetMembers(instanceBindingFlags).Select