TypeExtensions.TypeQualifiedName like in Hyperion (#4071)

* ported TypeExtensions.TypeQualifiedName resolution from Hyperion

* Unit test which proves that legacy and shortened types names are equivalent

* Check that shorter type manifest does not have version, culture and key attributes in it

src/core/Akka.Tests/Serialization/SerializationSpec.cs

@@ -6,13 +6,20 @@
 //-----------------------------------------------------------------------
 
 using System;
+using System.Collections.Concurrent;
+using System.IO;
+using System.Reflection;
+using System.Text.RegularExpressions;
 using Akka.Actor;
 using Akka.Configuration;
 using Akka.Dispatch.SysMsg;
 using Akka.Routing;
 using Akka.Serialization;
 using Akka.TestKit;
 using Akka.TestKit.TestActors;
+using Akka.Util;
+using Akka.Util.Reflection;
+using FluentAssertions;
 using Xunit;
 
 namespace Akka.Tests.Serialization
@@ -552,6 +559,29 @@ public void Can_apply_a_config_based_serializer_by_the_binding()
             dummy2.Config.GetString("test-key").ShouldBe("test value");
         }
 
+
+        private static string LegacyTypeQualifiedName(Type type)
+        {
+            string coreAssemblyName = typeof(object).GetTypeInfo().Assembly.GetName().Name;
+            var assemblyName = type.GetTypeInfo().Assembly.GetName().Name;
+            var shortened = assemblyName.Equals(coreAssemblyName)
+                ? type.GetTypeInfo().FullName
+                : $"{type.GetTypeInfo().FullName}, {assemblyName}";
+            return shortened;
+        }
+
+        [Fact]
+        public void Legacy_and_shortened_types_names_are_equivalent()
+        {
+            var targetType = typeof(ParentClass<OtherClassA, OtherClassB, OtherClassC>.ChildClass);
+
+            var legacyTypeManifest = LegacyTypeQualifiedName(targetType);
+            var newTypeManifest = targetType.TypeQualifiedName();
+
+            TypeCache.GetType(legacyTypeManifest).ShouldBeSame(TypeCache.GetType(newTypeManifest));
+            Type.GetType(legacyTypeManifest).ShouldBeSame(Type.GetType(newTypeManifest));
+        }
+
         public SerializationSpec():base(GetConfig())
         {
         }
@@ -638,6 +668,20 @@ public override object FromBinary(byte[] bytes, Type type)
                 throw new NotImplementedException();
             }
         }
+
+        public sealed class OtherClassA { }
+
+        public sealed class OtherClassB { }
+
+        public sealed class OtherClassC { }
+
+        public sealed class ParentClass<T1, T2, T3>
+        {
+            public sealed class ChildClass
+            {
+                public string Value { get; set; }
+            }
+        }
     }
 }
 

src/core/Akka.Tests/Util/TypeExtensionsTests.cs

@@ -5,10 +5,12 @@
 // </copyright>
 //-----------------------------------------------------------------------
 
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using Akka.TestKit;
 using Akka.Util;
+using FluentAssertions;
 using Xunit;
 
 namespace Akka.Tests.Util
@@ -33,6 +35,42 @@ public void Test_nongeneric_implements()
             typeof(List<string>).Implements(typeof(IEnumerable<string>)).ShouldBe(true);
             typeof(List<string>).Implements(typeof(IEnumerable<int>)).ShouldBe(false);
         }
+
+        public static IEnumerable<object[]> TargetTypes
+        {
+            get
+            {
+                yield return new object[] { typeof(ParentClass<OtherClassA, OtherClassB, OtherClassC>.ChildClass) };
+                yield return new object[] { typeof(string) };
+                yield return new object[] { typeof(object) };
+                yield return new object[] { typeof(TypeExtensionsTests) };
+            }
+        }
+
+        [Theory]
+        [MemberData(nameof(TargetTypes))]
+        public void Type_qualified_name_includes_only_typename_and_assemblyname(Type targetType)
+        {
+            var manifest = targetType.TypeQualifiedName();
+
+            manifest.Should().NotContain("Version");
+            manifest.Should().NotContain("Culture");
+            manifest.Should().NotContain("PublicKeyToken");
+        }
+
+        public sealed class OtherClassA { }
+
+        public sealed class OtherClassB { }
+
+        public sealed class OtherClassC { }
+
+        public sealed class ParentClass<T1, T2, T3>
+        {
+            public sealed class ChildClass
+            {
+                public string Value { get; set; }
+            }
+        }
     }
 }
 

src/core/Akka/Util/TypeExtensions.cs

@@ -8,6 +8,7 @@
 using System;
 using System.Collections.Concurrent;
 using System.Reflection;
+using System.Text.RegularExpressions;
 using Akka.Annotations;
 
 namespace Akka.Util
@@ -42,7 +43,10 @@ public static bool Implements(this Type type, Type moreGeneralType)
         }
 
         private static readonly ConcurrentDictionary<Type, string> ShortenedTypeNames = new ConcurrentDictionary<Type, string>();
-        private static readonly string CoreAssemblyName = typeof(object).GetTypeInfo().Assembly.GetName().Name;
+
+        private static readonly Regex cleanAssemblyVersionRegex = new Regex(
+            @"(, Version=([\d\.]+))?(, Culture=[^,\] \t]+)?(, PublicKeyToken=(null|[\da-f]+))?",
+            RegexOptions.Compiled | RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
 
         /// <summary>
         /// INTERNAL API
@@ -59,15 +63,11 @@ public static string TypeQualifiedName(this Type type)
             {
                 return shortened;
             }
-            else
-            {
-                var assemblyName = type.GetTypeInfo().Assembly.GetName().Name;
-                shortened = assemblyName.Equals(CoreAssemblyName)
-                    ? type.GetTypeInfo().FullName
-                    : $"{type.GetTypeInfo().FullName}, {assemblyName}";
-                ShortenedTypeNames.TryAdd(type, shortened);
-                return shortened;
-            }
+
+            shortened = cleanAssemblyVersionRegex.Replace(type.AssemblyQualifiedName, string.Empty);
+            ShortenedTypeNames.TryAdd(type, shortened);
+
+            return shortened;
         }
     }
 }