Allow case-sensitive type data collection

Author: Robert Holt

PSCompatibilityAnalyzer/Microsoft.PowerShell.CrossCompatibility/Data/Types/AssemblyData.cs

@@ -24,7 +24,7 @@ public class AssemblyData : ICloneable
         /// and then type name.
         /// </summary>
         [DataMember(EmitDefaultValue = false)]
-        public JsonCaseInsensitiveStringDictionary<JsonCaseInsensitiveStringDictionary<TypeData>> Types { get; set; }
+        public JsonDictionary<string, JsonDictionary<string, TypeData>> Types { get; set; }
 
         /// <summary>
         /// Create a deep clone of the assembly data object.
@@ -34,7 +34,7 @@ public object Clone()
             return new AssemblyData()
             {
                 AssemblyName = (AssemblyNameData)AssemblyName.Clone(),
-                Types = (JsonCaseInsensitiveStringDictionary<JsonCaseInsensitiveStringDictionary<TypeData>>)Types?.Clone()
+                Types = (JsonDictionary<string, JsonDictionary<string, TypeData>>)Types?.Clone()
             };
         }
     }

PSCompatibilityAnalyzer/Microsoft.PowerShell.CrossCompatibility/Data/Types/AvailableTypeData.cs

@@ -26,7 +26,7 @@ public class AvailableTypeData : ICloneable
         /// keyed by simple assembly name.
         /// </summary>
         [DataMember]
-        public JsonCaseInsensitiveStringDictionary<AssemblyData> Assemblies { get; set; }
+        public JsonDictionary<string, AssemblyData> Assemblies { get; set; }
 
         /// <summary>
         /// Create a deep clone of the available type data object.

PSCompatibilityAnalyzer/Microsoft.PowerShell.CrossCompatibility/Query/Types/AssemblyData.cs

@@ -38,10 +38,10 @@ public AssemblyData(Data.Types.AssemblyData assemblyData)
         /// </summary>
         public IReadOnlyDictionary<string, IReadOnlyDictionary<string, TypeData>> Types => _types?.Value;
 
-        private static IReadOnlyDictionary<string, IReadOnlyDictionary<string, TypeData>> CreateTypeDictionary(IReadOnlyDictionary<string, JsonCaseInsensitiveStringDictionary<Data.Types.TypeData>> typeData)
+        private static IReadOnlyDictionary<string, IReadOnlyDictionary<string, TypeData>> CreateTypeDictionary(IReadOnlyDictionary<string, JsonDictionary<string, Data.Types.TypeData>> typeData)
         {
             var namespaceDict = new Dictionary<string, IReadOnlyDictionary<string, TypeData>>(typeData.Count, StringComparer.OrdinalIgnoreCase);
-            foreach (KeyValuePair<string, JsonCaseInsensitiveStringDictionary<Data.Types.TypeData>> nspace in typeData)
+            foreach (KeyValuePair<string, JsonDictionary<string, Data.Types.TypeData>> nspace in typeData)
             {
                 var typeDict = new Dictionary<string, TypeData>(nspace.Value.Count, StringComparer.OrdinalIgnoreCase);
                 foreach (KeyValuePair<string, Data.Types.TypeData> type in nspace.Value)

PSCompatibilityAnalyzer/Microsoft.PowerShell.CrossCompatibility/Utility/ProfileCombination.cs

@@ -122,7 +122,7 @@ private static object Union(ParameterSetData thisParameterSet, ParameterSetData
 
         private static object Union(AvailableTypeData thisTypes, AvailableTypeData thatTypes)
         {
-            thisTypes.Assemblies = StringDictionaryUnion(thisTypes.Assemblies, thatTypes.Assemblies, Union);
+            thisTypes.Assemblies = DictionaryUnion(thisTypes.Assemblies, thatTypes.Assemblies, Union);
             thisTypes.TypeAccelerators = StringDictionaryUnion(thisTypes.TypeAccelerators, thatTypes.TypeAccelerators);
 
             return thisTypes;
@@ -136,18 +136,18 @@ private static object Union(AssemblyData thisAssembly, AssemblyData thatAssembly
             {
                 if (thisAssembly.Types == null)
                 {
-                    thisAssembly.Types = new JsonCaseInsensitiveStringDictionary<JsonCaseInsensitiveStringDictionary<TypeData>>();
+                    thisAssembly.Types = new JsonDictionary<string, JsonDictionary<string, TypeData>>();
                 }
 
-                foreach (KeyValuePair<string, JsonCaseInsensitiveStringDictionary<TypeData>> nspace in thatAssembly.Types)
+                foreach (KeyValuePair<string, JsonDictionary<string, TypeData>> nspace in thatAssembly.Types)
                 {
                     if (!thisAssembly.Types.ContainsKey(nspace.Key))
                     {
                         thisAssembly.Types.Add(nspace.Key, nspace.Value);
                         continue;
                     }
 
-                    thisAssembly.Types[nspace.Key] = StringDictionaryUnion(thisAssembly.Types[nspace.Key], nspace.Value, Union);
+                    thisAssembly.Types[nspace.Key] = DictionaryUnion(thisAssembly.Types[nspace.Key], nspace.Value, Union);
                 }
             }
 

PSCompatibilityAnalyzer/Microsoft.PowerShell.CrossCompatibility/Utility/TypeDataConversion.cs

@@ -50,7 +50,7 @@ public static AvailableTypeData AssembleAvailableTypes(
                 typeAcceleratorDict.Add(typeAccelerator.Key, ta);
             }
 
-            var asms = new JsonCaseInsensitiveStringDictionary<AssemblyData>();
+            var asms = new JsonDictionary<string, AssemblyData>();
             foreach (Assembly asm in assemblies)
             {
                 // Don't want to include this module or assembly in the output
@@ -96,10 +96,10 @@ public static KeyValuePair<string, AssemblyData> AssembleAssembly(Assembly asm)
             };
 
             Type[] types = asm.GetTypes();
-            JsonCaseInsensitiveStringDictionary<JsonCaseInsensitiveStringDictionary<TypeData>> namespacedTypes = null;
+            JsonDictionary<string, JsonDictionary<string, TypeData>> namespacedTypes = null;
             if (types.Any())
             {
-                namespacedTypes = new JsonCaseInsensitiveStringDictionary<JsonCaseInsensitiveStringDictionary<TypeData>>();
+                namespacedTypes = new JsonDictionary<string, JsonDictionary<string, TypeData>>();
                 foreach (Type type in asm.GetTypes())
                 {
                     if (!type.IsPublic)
@@ -110,14 +110,14 @@ public static KeyValuePair<string, AssemblyData> AssembleAssembly(Assembly asm)
                     // Some types don't have a namespace, but we still want to file them
                     string typeNamespace = type.Namespace ?? "";
 
-                    if (!namespacedTypes.ContainsKey(typeNamespace))
+                    if (!namespacedTypes.TryGetValue(typeNamespace, out JsonDictionary<string, TypeData> typeDictionary))
                     {
-                        namespacedTypes.Add(typeNamespace, new JsonCaseInsensitiveStringDictionary<TypeData>());
+                        typeDictionary = new JsonDictionary<string, TypeData>();
                     }
 
                     TypeData typeData = AssembleType(type);
 
-                    namespacedTypes[typeNamespace][type.Name] = typeData;
+                    typeDictionary[type.Name] = typeData;
                 }
             }
 
@@ -271,12 +271,12 @@ private static MemberData AssembleMembers(Type type, BindingFlags memberBinding)
             return new MemberData()
             {
                 Constructors = constructors.Any() ? constructors.Select(c => AssembleConstructor(c)).ToArray() : null,
-                Events = events.Any() ? new JsonCaseInsensitiveStringDictionary<EventData>(events.ToDictionary(e => e.Name, e => AssembleEvent(e), StringComparer.OrdinalIgnoreCase)) : null,
-                Fields = fields.Any() ? new JsonCaseInsensitiveStringDictionary<FieldData>(fields.ToDictionary(f => f.Name, f => AssembleField(f), StringComparer.OrdinalIgnoreCase)) : null,
+                Events = events.Any() ? new JsonCaseInsensitiveStringDictionary<EventData>(events.ToDictionary(e => e.Name, e => AssembleEvent(e))) : null,
+                Fields = fields.Any() ? new JsonCaseInsensitiveStringDictionary<FieldData>(fields.ToDictionary(f => f.Name, f => AssembleField(f))) : null,
                 Indexers = indexers.Any() ? indexers.Select(i => AssembleIndexer(i)).ToArray() : null,
-                Methods = methods.Any() ? new JsonCaseInsensitiveStringDictionary<MethodData>(methods.ToDictionary(m => m.Key, m => AssembleMethod(m.Value), StringComparer.OrdinalIgnoreCase)) : null,
-                NestedTypes = nestedTypes.Any() ? new JsonCaseInsensitiveStringDictionary<TypeData>(nestedTypes.ToDictionary(t => t.Name, t => AssembleType(t), StringComparer.OrdinalIgnoreCase)) : null,
-                Properties = properties.Any() ? new JsonCaseInsensitiveStringDictionary<PropertyData>(properties.ToDictionary(p => p.Name, p => AssembleProperty(p), StringComparer.OrdinalIgnoreCase)) : null
+                Methods = methods.Any() ? new JsonCaseInsensitiveStringDictionary<MethodData>(methods.ToDictionary(m => m.Key, m => AssembleMethod(m.Value))) : null,
+                NestedTypes = nestedTypes.Any() ? new JsonCaseInsensitiveStringDictionary<TypeData>(nestedTypes.ToDictionary(t => t.Name, t => AssembleType(t))) : null,
+                Properties = properties.Any() ? new JsonCaseInsensitiveStringDictionary<PropertyData>(properties.ToDictionary(p => p.Name, p => AssembleProperty(p))) : null
             };
         }