Full support for aliasing

Author: nkolev92

src/NuGet.Clients/NuGet.PackageManagement.VisualStudio/Projects/PackageReferenceProject.cs

@@ -444,7 +444,7 @@ private async ValueTask<IList<LockFileTarget>> GetTargetsListAsync(string assets
 
             await TaskScheduler.Default;
 
-            LockFile lockFile = LockFileUtilities.GetLockFile(assetsFilePath, NullLogger.Instance, LockFileReadFlags.PackageFolders | LockFileReadFlags.Targets);
+            LockFile lockFile = LockFileUtilities.GetLockFile(assetsFilePath, NullLogger.Instance, LockFileReadFlags.PackageFolders | LockFileReadFlags.Targets | LockFileReadFlags.PackageSpec);
             _packageFolders = lockFile?.PackageFolders ?? Array.Empty<LockFileItem>();
 
             return lockFile?.Targets;

src/NuGet.Core/NuGet.Build.Tasks/GetReferenceNearestTargetFrameworkTask.cs

@@ -42,6 +42,11 @@ public class GetReferenceNearestTargetFrameworkTask : Task
         public string CurrentProjectTargetPlatform { get; set; }
 
 
+        /// <summary>
+        /// The value of the current project's TargetFramework property.
+        /// </summary>
+        public string CurrentProjectTargetFrameworkProperty { get; set; }
+
         /// <summary>
         /// Optional list of target frameworks to be used as Fallback target frameworks.
         /// </summary>
@@ -153,7 +158,7 @@ private ITaskItem AssignNearestFrameworkForSingleReference(
 
             var packageSpec = new PackageSpec(targetFrameworkInformations);
 
-            var nearestNuGetFramework = packageSpec.GetTargetFramework(projectNuGetFramework);
+            var nearestNuGetFramework = packageSpec.GetNearestTargetFramework(projectNuGetFramework, CurrentProjectTargetFrameworkProperty);
 
             if (nearestNuGetFramework.FrameworkName != null)
             {
@@ -164,7 +169,7 @@ private ITaskItem AssignNearestFrameworkForSingleReference(
             // try project fallback frameworks
             foreach (var currentProjectTargetFramework in fallbackNuGetFrameworks)
             {
-                nearestNuGetFramework = packageSpec.GetTargetFramework(currentProjectTargetFramework);
+                nearestNuGetFramework = packageSpec.GetNearestTargetFramework(currentProjectTargetFramework, null);
 
                 if (nearestNuGetFramework.FrameworkName != null)
                 {

src/NuGet.Core/NuGet.Build.Tasks/NuGet.targets

@@ -59,6 +59,8 @@ Copyright (c) .NET Foundation. All rights reserved.
     <PackageDownloadSupported>true</PackageDownloadSupported>
     <!-- Mark that this targets file GetReferenceNearestTargetFrameworkTask task supports the TargetPlatformMoniker -->
     <GetReferenceNearestTargetFrameworkTaskSupportsTargetPlatformParameter>true</GetReferenceNearestTargetFrameworkTaskSupportsTargetPlatformParameter>
+    <!-- Mark that this targets file GetReferenceNearestTargetFrameworkTask task supports the TargetFramework -->
+    <GetReferenceNearestTargetFrameworkTaskSupportsTargetFrameworKPropertyParameter>true</GetReferenceNearestTargetFrameworkTaskSupportsTargetFrameworKPropertyParameter>
     <!-- Flag if the Central package file is enabled -->
     <_CentralPackageVersionsEnabled Condition="'$(ManagePackageVersionsCentrally)' == 'true' AND '$(CentralPackageVersionsFileImported)' == 'true'">true</_CentralPackageVersionsEnabled>
   </PropertyGroup>

src/NuGet.Core/NuGet.Commands/GlobalSuppressions.cs

@@ -96,7 +96,6 @@
 [assembly: SuppressMessage("Build", "CA1303:Method 'void PackCommandRunner.PrintVerbose(string outputPath, PackageBuilder builder)' passes a literal string as parameter 'message' of a call to 'void PackCommandRunner.WriteLine(string message, object arg = null)'. Retrieve the following string(s) from a resource table instead: \"Version: {0}\".", Justification = "<Pending>", Scope = "member", Target = "~M:NuGet.Commands.PackCommandRunner.PrintVerbose(System.String,NuGet.Packaging.PackageBuilder)")]
 [assembly: SuppressMessage("Build", "CA1062:In externally visible method 'void PackCommandRunner.SetupCurrentDirectory(PackArgs packArgs)', validate parameter 'packArgs' is non-null before using it. If appropriate, throw an ArgumentNullException when the argument is null or add a Code Contract precondition asserting non-null argument.", Justification = "<Pending>", Scope = "member", Target = "~M:NuGet.Commands.PackCommandRunner.SetupCurrentDirectory(NuGet.Commands.PackArgs)")]
 [assembly: SuppressMessage("Build", "CA1062:In externally visible method 'void RemoveSourceRunner.Run(RemoveSourceArgs args, Func<ILogger> getLogger)', validate parameter 'getLogger' is non-null before using it. If appropriate, throw an ArgumentNullException when the argument is null or add a Code Contract precondition asserting non-null argument.", Justification = "<Pending>", Scope = "member", Target = "~M:NuGet.Commands.RemoveSourceRunner.Run(NuGet.Commands.RemoveSourceArgs,System.Func{NuGet.Common.ILogger})")]
-[assembly: SuppressMessage("Build", "CA1062:In externally visible method 'void RestoreArgs.ApplyStandardProperties(RestoreRequest request)', validate parameter 'request' is non-null before using it. If appropriate, throw an ArgumentNullException when the argument is null or add a Code Contract precondition asserting non-null argument.", Justification = "<Pending>", Scope = "member", Target = "~M:NuGet.Commands.RestoreArgs.ApplyStandardProperties(NuGet.Commands.RestoreRequest)")]
 [assembly: SuppressMessage("Build", "CA1822:Member GetEffectiveFallbackPackageFolders does not access instance data and can be marked as static (Shared in VisualBasic)", Justification = "<Pending>", Scope = "member", Target = "~M:NuGet.Commands.RestoreArgs.GetEffectiveFallbackPackageFolders(NuGet.Configuration.ISettings)~System.Collections.Generic.IReadOnlyList{System.String}")]
 [assembly: SuppressMessage("Build", "CA1062:In externally visible method 'void RestoreCollectorLogger.ApplyRestoreInputs(PackageSpec projectSpec)', validate parameter 'projectSpec' is non-null before using it. If appropriate, throw an ArgumentNullException when the argument is null or add a Code Contract precondition asserting non-null argument.", Justification = "<Pending>", Scope = "member", Target = "~M:NuGet.Commands.RestoreCollectorLogger.ApplyRestoreInputs(NuGet.ProjectModel.PackageSpec)")]
 [assembly: SuppressMessage("Build", "CA1062:In externally visible method 'bool RestoreCollectorLogger.DisplayMessage(IRestoreLogMessage message)', validate parameter 'message' is non-null before using it. If appropriate, throw an ArgumentNullException when the argument is null or add a Code Contract precondition asserting non-null argument.", Justification = "<Pending>", Scope = "member", Target = "~M:NuGet.Commands.RestoreCollectorLogger.DisplayMessage(NuGet.Common.IRestoreLogMessage)~System.Boolean")]

src/NuGet.Core/NuGet.Commands/PublicAPI/netstandard2.0/PublicAPI.Unshipped.txt

@@ -1 +1,2 @@
 #nullable enable
+~NuGet.Commands.SourceRepositoryDependencyProvider.FindLibraryAsync(NuGet.LibraryModel.LibraryRange! libraryRange, NuGet.Frameworks.NuGetFramework! targetFramework, string! targetAlias, NuGet.Protocol.Core.Types.SourceCacheContext! cacheContext, NuGet.Common.ILogger! logger, System.Threading.CancellationToken cancellationToken) -> System.Threading.Tasks.Task<NuGet.LibraryModel.LibraryIdentity!>!

src/NuGet.Core/NuGet.Commands/RestoreCommand/DependencyGraphResolver.cs

@@ -195,6 +195,7 @@ public async Task<ValueTuple<bool, List<RestoreTargetGraph>, RuntimeGraph>> Reso
                         _rootProjectLibraryDependency.LibraryRange,
                         frameworkRuntimeDefinition.Framework,
                         runtimeIdentifier: string.IsNullOrWhiteSpace(frameworkRuntimeDefinition.RuntimeIdentifier) ? null : frameworkRuntimeDefinition.RuntimeIdentifier,
+                        frameworkRuntimeDefinition.TargetAlias,
                         context,
                         token),
                     Parent = LibraryRangeIndex.None
@@ -1394,6 +1395,7 @@ .. chosenResolvedItem.Suppressions
                             childDependency.LibraryRange,
                             pair.Framework,
                             runtimeIdentifier: string.IsNullOrWhiteSpace(pair.RuntimeIdentifier) ? null : pair.RuntimeIdentifier,
+                            pair.TargetAlias,
                             context,
                             token)
                     };

src/NuGet.Core/NuGet.Commands/RestoreCommand/LockFileBuilder.cs

@@ -162,12 +162,20 @@ public LockFile CreateLockFile(LockFile previousLockFile,
                 .OrderBy(graph => graph.Framework.ToString(), StringComparer.Ordinal)
                 .ThenBy(graph => graph.RuntimeIdentifier, StringComparer.Ordinal))
             {
-                var target = new LockFileTarget
-                {
-                    TargetFramework = targetGraph.Framework,
-                    RuntimeIdentifier = targetGraph.RuntimeIdentifier,
-                    TargetAlias = targetGraph.TargetAlias,
-                };
+                var target = lockFile.Version >= 4 ?
+                    new LockFileTarget
+                    {
+                        TargetFramework = targetGraph.Framework,
+                        RuntimeIdentifier = targetGraph.RuntimeIdentifier,
+                        TargetAlias = targetGraph.TargetAlias,
+                        Name = targetGraph.TargetGraphName
+                    } :
+                    new LockFileTarget
+                    {
+                        TargetFramework = targetGraph.Framework,
+                        RuntimeIdentifier = targetGraph.RuntimeIdentifier,
+                        TargetAlias = targetGraph.TargetAlias,
+                    };
 
                 var flattenedFlags = IncludeFlagUtils.FlattenDependencyTypes(_includeFlagGraphs, project, targetGraph);
 
@@ -389,20 +397,24 @@ private static string GetFallbackFrameworkString(NuGetFramework framework)
             return string.Join(", ", frameworks);
         }
 
-        private static void AddProjectFileDependenciesForPackageReference(PackageSpec project, LockFile lockFile, IEnumerable<RestoreTargetGraph> targetGraphs)
+        private static void AddProjectFileDependenciesForPackageReference(PackageSpec project, LockFile lockFile, List<RestoreTargetGraph> targetGraphs)
         {
-            // For NETCore put everything under a TFM section
-            // Projects are included for NETCore
+            bool isV4LockFile = lockFile.Version >= 4;
+
             foreach (var frameworkInfo in project.TargetFrameworks
-                .OrderBy(framework => framework.FrameworkName.ToString(),
+                .OrderBy(framework => framework.TargetAlias,
                     StringComparer.Ordinal))
             {
                 var dependencies = new List<LibraryRange>();
                 dependencies.AddRange(frameworkInfo.Dependencies.Select(e => e.LibraryRange));
 
-                var targetGraph = targetGraphs.SingleOrDefault(graph =>
-                    graph.Framework.Equals(frameworkInfo.FrameworkName)
-                    && string.IsNullOrEmpty(graph.RuntimeIdentifier));
+                RestoreTargetGraph targetGraph = !string.IsNullOrEmpty(frameworkInfo.TargetAlias) ?
+                    targetGraphs.SingleOrDefault(graph =>
+                        frameworkInfo.TargetAlias.Equals(graph.TargetAlias)
+                        && string.IsNullOrEmpty(graph.RuntimeIdentifier)) :
+                    targetGraphs.SingleOrDefault(graph =>
+                        graph.Framework.Equals(frameworkInfo.FrameworkName)
+                        && string.IsNullOrEmpty(graph.RuntimeIdentifier));
 
                 var resolvedEntry = targetGraph?
                     .Flattened
@@ -428,8 +440,9 @@ private static void AddProjectFileDependenciesForPackageReference(PackageSpec pr
                 }
 
                 // Add entry
+                string framework = (isV4LockFile && string.IsNullOrEmpty(frameworkInfo.TargetAlias)) ? frameworkInfo.TargetAlias : frameworkInfo.FrameworkName.ToString();
                 var dependencyGroup = new ProjectFileDependencyGroup(
-                    frameworkInfo.FrameworkName.ToString(),
+                    framework,
                     uniqueDependencies.Select(x => x.ToLockFileDependencyGroupString())
                         .OrderBy(dependency => dependency, StringComparer.Ordinal));
 

src/NuGet.Core/NuGet.Commands/RestoreCommand/RequestFactory/RestoreArgs.cs

@@ -184,6 +184,8 @@ private List<SourceRepository> GetEffectiveSourcesCore(ISettings settings, IList
 
         public void ApplyStandardProperties(RestoreRequest request)
         {
+            if (request == null) throw new ArgumentNullException(nameof(request));
+
             if (request.ProjectStyle == ProjectStyle.PackageReference)
             {
                 request.LockFilePath = Path.Combine(request.RestoreOutputPath, LockFileFormat.AssetsFileName);
@@ -203,7 +205,8 @@ public void ApplyStandardProperties(RestoreRequest request)
 
             request.RequestedRuntimes.UnionWith(Runtimes);
             request.FallbackRuntimes.UnionWith(FallbackRuntimes);
-            request.LockFileVersion = LockFileFormat.Version;
+            // Use v3 for classic csproj.
+            request.LockFileVersion = request.Project.RestoreMetadata?.UsingMicrosoftNETSdk == true ? LockFileFormat.Version : 3;
 
             // Run runtime asset checks for project.json, and for other types if enabled.
             if (ValidateRuntimeAssets == null)

src/NuGet.Core/NuGet.Commands/RestoreCommand/RestoreCommand.cs

@@ -1462,8 +1462,10 @@ private LockFile BuildAssetsFile(
             IReadOnlyList<NuGetv3LocalRepository> localRepositories,
             RemoteWalkContext contextForProject)
         {
+            int lockFileVersion = DetermineLockFileVersion();
+
             // Build the lock file
-            var lockFile = new LockFileBuilder(_request.LockFileVersion, _logger, _includeFlagGraphs)
+            var lockFile = new LockFileBuilder(lockFileVersion, _logger, _includeFlagGraphs)
                     .CreateLockFile(
                         existingLockFile,
                         project,
@@ -1473,6 +1475,23 @@ private LockFile BuildAssetsFile(
                         _lockFileBuilderCache);
 
             return lockFile;
+
+            int DetermineLockFileVersion()
+            {
+                int lockFileVersion = _request.LockFileVersion;
+
+                // We use the request provided version, unless we are using the Microsoft.NET.Sdk that does not support reading of aliased assets files.
+                if (_request.Project.RestoreMetadata.UsingMicrosoftNETSdk &&
+                    !SdkAnalysisLevelMinimums.IsEnabled(
+                    _request.Project.RestoreMetadata.SdkAnalysisLevel,
+                    _request.Project.RestoreMetadata.UsingMicrosoftNETSdk,
+                    SdkAnalysisLevelMinimums.V10_0_300))
+                {
+                    lockFileVersion = 3;
+                }
+
+                return lockFileVersion;
+            }
         }
 
         /// <summary>
@@ -1660,6 +1679,17 @@ private static async Task<IList<CompatibilityCheckResult>> VerifyCompatibilityAs
             TelemetryActivity telemetryActivity)
         {
             bool success = true;
+
+            // Check for duplicate frameworks. The new dependency resolver supports aliasing, but the legacy one does not.
+            if (_request.Project.TargetFrameworks.Count != new HashSet<NuGetFramework>(_request.Project.TargetFrameworks.Select(e => e.FrameworkName)).Count)
+            {
+                var message = string.Format(CultureInfo.CurrentCulture, Strings.Log_AliasingSupportedInNewDependencyResolver, _request.Project.Name, SdkAnalysisLevelMinimums.V10_0_300);
+                await _logger.LogAsync(RestoreLogMessage.CreateError(NuGetLogCode.NU1018, message));
+
+                success = false;
+                return (success, []);
+            }
+
             if (_request.Project.TargetFrameworks.Count == 0)
             {
                 var message = string.Format(CultureInfo.CurrentCulture, Strings.Log_ProjectDoesNotSpecifyTargetFrameworks, _request.Project.Name, _request.Project.FilePath);
@@ -1847,6 +1877,25 @@ private static async Task<IList<CompatibilityCheckResult>> VerifyCompatibilityAs
                 return (success, []);
             }
 
+
+            bool shouldDoDuplicatesCheck = _request.Project.RestoreMetadata.UsingMicrosoftNETSdk &&
+                    !SdkAnalysisLevelMinimums.IsEnabled(
+                    _request.Project.RestoreMetadata.SdkAnalysisLevel,
+                    _request.Project.RestoreMetadata.UsingMicrosoftNETSdk,
+                    SdkAnalysisLevelMinimums.V10_0_300);
+
+            if (shouldDoDuplicatesCheck)
+            {
+                if (_request.Project.TargetFrameworks.Count != new HashSet<NuGetFramework>(_request.Project.TargetFrameworks.Select(e => e.FrameworkName)).Count)
+                {
+                    var message = string.Format(CultureInfo.CurrentCulture, Strings.Log_AliasingSupportedInNewDependencyResolver, _request.Project.Name, SdkAnalysisLevelMinimums.V10_0_300);
+                    await _logger.LogAsync(RestoreLogMessage.CreateError(NuGetLogCode.NU1018, message));
+
+                    success = false;
+                    return (success, []);
+                }
+            }
+
             var projectRestoreRequest = new ProjectRestoreRequest(_request, _request.Project, _request.ExistingLockFile, _logger)
             {
                 ParentId = _operationId

src/NuGet.Core/NuGet.Commands/RestoreCommand/SourceRepositoryDependencyProvider.cs

@@ -341,7 +341,8 @@ public Task<LibraryDependencyInfo> GetDependenciesAsync(
 
             cancellationToken.ThrowIfCancellationRequested();
 
-            LibraryRangeCacheKey key = new(libraryIdentity, targetFramework);
+            // Pass an empty alias since aliases are not supported for packages.
+            LibraryRangeCacheKey key = new(libraryIdentity, targetFramework, alias: string.Empty);
 
             return _dependencyInfoCache.GetOrAddAsync(
                 key,