better fix

Author: bahusoid

src/NHibernate/Type/TypeFactory.cs

@@ -535,7 +535,7 @@ public static IType HeuristicType(string typeName)
 		/// </remarks>
 		public static IType HeuristicType(System.Type type)
 		{
-			return HeuristicType(type, typeName: null, parameters: null, length: null);
+			return HeuristicType(type, parameters: null, length: null);
 		}
 
 		/// <summary>
@@ -558,56 +558,50 @@ public static IType HeuristicType(string typeName, IDictionary<string, string> p
 		/// <returns></returns>
 		public static IType HeuristicType(string typeName, IDictionary<string, string> parameters, int? length)
 		{
-			return HeuristicType(/*resolvedType:*/ null, typeName, parameters, length);
-		}
-
-		/// <summary>
-		/// Provide either resolvedType or typeName. resolvedType takes precedence.
-		/// </summary>
-		private static IType HeuristicType(System.Type resolvedType, string typeName, IDictionary<string, string> parameters, int? length)
-		{
-			IType type = Basic(resolvedType?.AssemblyQualifiedName ?? typeName, parameters);
+			IType type = Basic(typeName, parameters);
 
 			if (type != null)
 				return type;
 
-			if (resolvedType == null)
+			string[] parsedTypeName;
+			var typeClassification = GetTypeClassification(typeName);
+			if (typeClassification == TypeClassification.LengthOrScale)
 			{
-				string[] parsedTypeName;
-				var typeClassification = GetTypeClassification(typeName);
-				if (typeClassification == TypeClassification.LengthOrScale)
+				parsedTypeName = typeName.Split(LengthSplit);
+				if (!int.TryParse(parsedTypeName[1], out int parsedLength))
 				{
-					parsedTypeName = typeName.Split(LengthSplit);
-					if(!int.TryParse(parsedTypeName[1], out int parsedLength))
-					{
-						throw new MappingException($"Could not parse length value '{parsedTypeName[1]}' as int for type '{typeName}'");
-					}
-					length = parsedLength;
+					throw new MappingException($"Could not parse length value '{parsedTypeName[1]}' as int for type '{typeName}'");
 				}
-				else
-					parsedTypeName = typeClassification == TypeClassification.PrecisionScale ? typeName.Split(PrecisionScaleSplit) : new[] { typeName };
+				length = parsedLength;
+			}
+			else
+				parsedTypeName = typeClassification == TypeClassification.PrecisionScale ? typeName.Split(PrecisionScaleSplit) : new[] { typeName };
 
-				try
-				{
-					resolvedType = ReflectHelper.ClassForName(parsedTypeName[0]); //typeName);
-				}
-				catch (Exception)
-				{
-					return null;
-				}
+			System.Type typeClass;
+			try
+			{
+				typeClass = ReflectHelper.ClassForName(parsedTypeName[0]); //typeName);
+			}
+			catch (Exception)
+			{
+				return null;
 			}
-			var typeClass = resolvedType;
+			return HeuristicType(typeClass, parameters, length);
+		}
+
+		private static IType HeuristicType(System.Type typeClass, IDictionary<string, string> parameters, int? length)
+		{
 			if (typeof(IType).IsAssignableFrom(typeClass))
 			{
 				try
 				{
-					type = (IType) Environment.ObjectsFactory.CreateInstance(typeClass);
+					var type = (IType) Environment.ObjectsFactory.CreateInstance(typeClass);
 					InjectParameters(type, parameters);
 
 					var obsolete = typeClass.GetCustomAttribute<ObsoleteAttribute>(false);
 					if (obsolete != null)
 					{
-						_log.Warn("{0} is obsolete. {1}", typeName, obsolete.Message);
+						_log.Warn("{0} is obsolete. {1}", typeClass.AssemblyQualifiedName, obsolete.Message);
 					}
 					return type;
 				}
@@ -632,7 +626,7 @@ private static IType HeuristicType(System.Type resolvedType, string typeName, ID
 			var unwrapped = typeClass.UnwrapIfNullable();
 			if (unwrapped.IsEnum)
 			{
-				return (IType) Activator.CreateInstance(typeof (EnumType<>).MakeGenericType(unwrapped));
+				return (IType) Activator.CreateInstance(typeof(EnumType<>).MakeGenericType(unwrapped));
 			}
 
 			if (!typeClass.IsSerializable)
@@ -641,7 +635,7 @@ private static IType HeuristicType(System.Type resolvedType, string typeName, ID
 			if (length.HasValue)
 				return GetSerializableType(typeClass, length.Value);
 
-			return GetSerializableType(typeClass);
+			return GetSerializedOrBasicType(typeClass);
 		}
 
 		/// <summary>
@@ -709,14 +703,19 @@ private static NullableType GetType(NullableType defaultUnqualifiedType, byte pr
 		/// </para>
 		/// </remarks>
 		public static NullableType GetSerializableType(System.Type serializableType)
+		{
+			return (NullableType) GetSerializedOrBasicType(serializableType);
+		}
+
+		private static IType GetSerializedOrBasicType(System.Type serializableType)
 		{
 			var key = serializableType.AssemblyQualifiedName;
 
 			// The value factory may be run concurrently, but only one resulting value will be yielded to all threads.
 			// So we should add the type with its other key in a later operation in order to ensure we cache the same
 			// instance for both keys.
 			var added = false;
-			var type = (NullableType)typeByTypeOfName.GetOrAdd(
+			var type = typeByTypeOfName.GetOrAdd(
 				key,
 				k =>
 				{