Make PackageSpecDependencyProvider consider the version being requested

src/NuGet.Core/NuGet.ProjectModel/PackageSpecReferenceDependencyProvider.cs

@@ -86,7 +86,15 @@ public Library GetLibrary(LibraryRange libraryRange, NuGetFramework targetFramew
             // This must exist in the external references
             if (_externalProjectsByUniqueName.TryGetValue(name, out ExternalProjectReference externalReference))
             {
-                packageSpec = externalReference.PackageSpec;
+                if (externalReference.PackageSpec == null ||
+                    libraryRange.VersionRange.FindBestMatch(new NuGetVersion[] { externalReference.PackageSpec.Version }) != null)
+                {
+                    packageSpec = externalReference.PackageSpec;
+                }
+                else
+                {
+                    externalReference = null;
+                }
             }
 
             if (externalReference == null && packageSpec == null)

test/NuGet.Core.FuncTests/NuGet.Commands.FuncTest/RestoreCommandTests.cs

@@ -3238,8 +3238,8 @@ await SimpleTestPackageUtility.CreateFolderFeedV3Async(
 
                 // Act
                 result = await newCommand.ExecuteAsync();
-                // Assert
 
+                // Assert
                 await result.CommitAsync(logger, CancellationToken.None);
                 result.Success.Should().BeTrue(because: logger.ShowMessages());
                 result.Should().BeAssignableTo<NoOpRestoreResult>(because: "This should be a no-op restore.");

test/NuGet.Core.Tests/NuGet.Commands.Test/RestoreCommandTests/RestoreCommandTests.cs

@@ -3190,6 +3190,87 @@ public async Task ExecuteAsync_TransitiveDependenciesFromNonRootLibraries_AreIgn
             }
         }
 
+        [Fact]
+        public async Task ExecuteAsync_WithConditionalProjectAndPackageReferences_SelectsPackageWhereProjectIsNotAppropriate()
+        {
+            // Arrange
+            using var context = new SourceCacheContext();
+            using var pathContext = new SimpleTestPathContext();
+
+            var mainProject = "main";
+            var mainProjectPath = Path.Combine(pathContext.SolutionRoot, mainProject);
+
+            var systemNumericsVectorName = "System.Numerics.Vectors";
+            var childProjectPath = Path.Combine(pathContext.SolutionRoot, systemNumericsVectorName);
+
+            var mainProjectJson = @"
+            {
+              ""version"": ""1.0.0"",
+              ""frameworks"": {
+                ""netstandard2.0"": {
+                    ""dependencies"": {
+                        ""System.Memory"": {
+                                      ""target"": ""Package"",
+                                      ""version"": ""[4.5.5, )""
+                                    },
+                          ""NETStandard.Library"": {
+                                      ""suppressParent"": ""All"",
+                                      ""target"": ""Package"",
+                                      ""version"": ""[2.0.3, )"",
+                                      ""autoReferenced"": true
+                                    }
+                    }
+                },
+                ""net8.0"": {
+                    ""dependencies"": {
+                    }
+                }
+              }
+            }";
+            PackageSpec systemNumericsVectorPackageSpec = ProjectTestHelpers.GetPackageSpec(systemNumericsVectorName, pathContext.SolutionRoot, "net8.0");
+            PackageSpec mainPackageSpec = ProjectTestHelpers.GetPackageSpecWithProjectNameAndSpec(mainProject, pathContext.SolutionRoot, mainProjectJson);
+            var settings = Settings.LoadDefaultSettings(pathContext.SolutionRoot);
+            mainPackageSpec.RestoreMetadata.ConfigFilePaths = settings.GetConfigFilePaths();
+            mainPackageSpec.RestoreMetadata.Sources = SettingsUtility.GetEnabledSources(settings).ToList();
+            mainPackageSpec.RestoreMetadata.FallbackFolders = SettingsUtility.GetFallbackPackageFolders(settings).ToList();
+            mainPackageSpec.RestoreMetadata.PackagesPath = SettingsUtility.GetGlobalPackagesFolder(settings);
+
+            mainPackageSpec.RestoreMetadata.TargetFrameworks.Single(e => e.FrameworkName.Equals(NuGetFramework.Parse("net8.0")))
+                .ProjectReferences.Add(new ProjectRestoreReference()
+            {
+                ProjectUniqueName = systemNumericsVectorPackageSpec.RestoreMetadata.ProjectUniqueName,
+                ProjectPath = systemNumericsVectorPackageSpec.RestoreMetadata.ProjectPath,
+            });
+
+            // create packages
+            var ns203 = new SimpleTestPackageContext("NETStandard.Library", "2.0.3");
+            var systemMemory = new SimpleTestPackageContext("System.Memory", "4.5.5");
+            var systemNumericsVector = new SimpleTestPackageContext(systemNumericsVectorName, "4.4.0");
+            systemMemory.Dependencies.Add(systemNumericsVector);
+
+            await SimpleTestPackageUtility.CreateFolderFeedV3Async(pathContext.PackageSource,
+                ns203,
+                systemMemory,
+                systemNumericsVector);
+
+            var logger = new TestLogger();
+            var request = ProjectTestHelpers.CreateRestoreRequest(pathContext, logger, mainPackageSpec, systemNumericsVectorPackageSpec);
+
+            var restoreCommand = new RestoreCommand(request);
+            RestoreResult result = await restoreCommand.ExecuteAsync();
+
+            result.Success.Should().BeTrue(because: logger.ShowMessages());
+            result.LockFile.LogMessages.Should().BeEmpty();
+            var net80Target = result.LockFile.Targets.Single(e => e.TargetFramework.Equals(NuGetFramework.Parse("net8.0")));
+            var netstandard20 = result.LockFile.Targets.Single(e => e.TargetFramework.Equals(NuGetFramework.Parse("netstandard2.0")));
+            net80Target.Libraries.Should().HaveCount(1);
+            var net80Vectors = net80Target.Libraries.Single(e => e.Name.Equals(systemNumericsVectorName));
+            net80Vectors.Version.Should().Be(new NuGetVersion(1, 0, 0));
+            netstandard20.Libraries.Should().HaveCount(3);
+            var ns20Target = netstandard20.Libraries.Single(e => e.Name.Equals(systemNumericsVectorName));
+            ns20Target.Version.Should().Be(new NuGetVersion(4, 4, 0));
+        }
+
         private static PackageSpec GetPackageSpec(string projectName, string testDirectory, string referenceSpec)
         {
             return JsonPackageSpecReader.GetPackageSpec(referenceSpec, projectName, testDirectory).WithTestRestoreMetadata();

test/TestUtilities/Test.Utility/Commands/TestRestoreRequest.cs

@@ -205,6 +205,7 @@ public TestRestoreRequest(
             DependencyGraphSpec.AddProject(project);
             DependencyGraphSpec.AddRestore(project.RestoreMetadata.ProjectUniqueName);
             AllowNoOp = true;
+            ProjectStyle = project.RestoreMetadata.ProjectStyle;
         }
     }
 }