AOT Compatible: ManifestVersionUtility (#7128)

Author: Nigusu-Allehu

src/NuGet.Core/NuGet.Packaging/PackageCreation/Authoring/ManifestMetadata.cs

@@ -68,7 +68,6 @@ public ManifestMetadata(IPackageMetadata copy)
             Readme = copy.Readme;
         }
 
-        [ManifestVersion(5)]
         public string MinClientVersionString
         {
             get { return _minClientVersionString; }
@@ -173,10 +172,8 @@ public Uri ProjectUrl
 
         public string Summary { get; set; }
 
-        [ManifestVersion(2)]
         public string ReleaseNotes { get; set; }
 
-        [ManifestVersion(2)]
         public string Copyright { get; set; }
 
         public string Language { get; set; }
@@ -208,7 +205,6 @@ public IEnumerable<PackageDependencyGroup> DependencyGroups
 
         private IEnumerable<PackageReferenceSet> _packageAssemblyReferences = [];
 
-        [ManifestVersion(2)]
         public IEnumerable<PackageReferenceSet> PackageAssemblyReferences
         {
             get

src/NuGet.Core/NuGet.Packaging/PackageCreation/Authoring/ManifestVersionAttribute.cs

@@ -4,9 +4,7 @@
 #nullable disable
 
 using System;
-using System.Collections;
 using System.Linq;
-using System.Reflection;
 
 namespace NuGet.Packaging
 {
@@ -21,102 +19,39 @@ public static class ManifestVersionUtility
 
         public static int GetManifestVersion(ManifestMetadata metadata)
         {
-            return Math.Max(GetVersionFromObject(metadata), GetMaxVersionFromMetadata(metadata));
-        }
-
-        private static int GetMaxVersionFromMetadata(ManifestMetadata metadata)
-        {
-            // Important: always add newer version checks at the top
-
-            bool referencesHasTargetFramework =
-              metadata.PackageAssemblyReferences != null &&
-              metadata.PackageAssemblyReferences.Any(r => r.TargetFramework != null && r.TargetFramework.IsSpecificFramework);
-
-            if (referencesHasTargetFramework)
-            {
-                return TargetFrameworkSupportForReferencesVersion;
-            }
-
-            bool dependencyHasTargetFramework =
-                metadata.DependencyGroups != null &&
-                metadata.DependencyGroups.Any(d => d.TargetFramework != null && d.TargetFramework.IsSpecificFramework);
-            if (dependencyHasTargetFramework)
-            {
-                return TargetFrameworkSupportForDependencyContentsAndToolsVersion;
-            }
-
-            if (metadata.Version != null && metadata.Version.IsPrerelease)
+            if (metadata == null)
             {
-                return SemverVersion;
+                throw new ArgumentNullException(nameof(metadata));
             }
 
-            return DefaultVersion;
-        }
-
-        private static int GetVersionFromObject(object obj)
-        {
-            // all public, gettable, non-static properties
-            return obj?.GetType()
-                       .GetRuntimeProperties()
-                       .Where(prop => prop.GetMethod != null && prop.GetMethod.IsPublic && !prop.GetMethod.IsStatic)
-                       .Max(prop => GetVersionFromPropertyInfo(obj, prop))
-                      ?? DefaultVersion;
-        }
-
-        private static int GetVersionFromPropertyInfo(object obj, PropertyInfo property)
-        {
-            var value = property.GetValue(obj, index: null);
-            if (value == null)
-            {
-                return DefaultVersion;
-            }
+            // Important: always add newer version checks at the top
 
-            int? version = GetPropertyVersion(property);
-            if (!version.HasValue)
+            if ((metadata.PackageAssemblyReferences != null &&
+                metadata.PackageAssemblyReferences.Any(r => r.TargetFramework != null && r.TargetFramework.IsSpecificFramework)) ||
+                !string.IsNullOrEmpty(metadata.MinClientVersionString))
             {
-                return DefaultVersion;
+                return 5;
             }
 
-            var list = value as IList;
-            if (list != null)
+            if (metadata.DependencyGroups != null &&
+                metadata.DependencyGroups.Any(d => d.TargetFramework != null && d.TargetFramework.IsSpecificFramework))
             {
-                if (list.Count > 0)
-                {
-                    return Math.Max(version.Value, VisitList(list));
-                }
-                return DefaultVersion;
+                return 4;
             }
 
-            var stringValue = value as string;
-            if (stringValue != null)
+            if (metadata.Version != null && metadata.Version.IsPrerelease)
             {
-                if (!string.IsNullOrEmpty(stringValue))
-                {
-                    return version.Value;
-                }
-                return DefaultVersion;
+                return 3;
             }
 
-            // For all other object types a null check would suffice.
-            return version.Value;
-        }
-
-        private static int VisitList(IEnumerable list)
-        {
-            int version = DefaultVersion;
-
-            foreach (var item in list)
+            if (!string.IsNullOrEmpty(metadata.ReleaseNotes) ||
+                !string.IsNullOrEmpty(metadata.Copyright) ||
+                (metadata.PackageAssemblyReferences?.Any() ?? false))
             {
-                version = Math.Max(version, GetVersionFromObject(item));
+                return 2;
             }
 
-            return version;
-        }
-
-        private static int? GetPropertyVersion(PropertyInfo property)
-        {
-            var attribute = property.GetCustomAttribute<ManifestVersionAttribute>();
-            return attribute?.Version;
+            return DefaultVersion;
         }
     }
 }