diff --git a/src/NuGet.Clients/NuGet.SolutionRestoreManager/SolutionRestoreJob.cs b/src/NuGet.Clients/NuGet.SolutionRestoreManager/SolutionRestoreJob.cs
index 84da4052583..15bebb6db75 100644
--- a/src/NuGet.Clients/NuGet.SolutionRestoreManager/SolutionRestoreJob.cs
+++ b/src/NuGet.Clients/NuGet.SolutionRestoreManager/SolutionRestoreJob.cs
@@ -315,15 +315,17 @@ private async Task RestoreAsync(bool forceRestore, RestoreOperationSource restor
                             var providerCache = new RestoreCommandProvidersCache();
                             Action<SourceCacheContext> cacheModifier = (cache) => { };
 
+                            var isRestoreOriginalAction = true;
                             var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                                 _solutionManager,
+                                dgSpec,
                                 cacheContext,
                                 providerCache,
                                 cacheModifier,
                                 sources,
                                 _nuGetProjectContext.OperationId,
                                 forceRestore,
-                                dgSpec,
+                                isRestoreOriginalAction,
                                 l,
                                 t);
 
diff --git a/src/NuGet.Core/NuGet.Commands/PackagesLockFileBuilder.cs b/src/NuGet.Core/NuGet.Commands/PackagesLockFileBuilder.cs
index a7114acd64a..71e80557963 100644
--- a/src/NuGet.Core/NuGet.Commands/PackagesLockFileBuilder.cs
+++ b/src/NuGet.Core/NuGet.Commands/PackagesLockFileBuilder.cs
@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System;
 using System.Linq;
 using NuGet.Common;
 using NuGet.LibraryModel;
@@ -12,19 +13,9 @@ namespace NuGet.Commands
 {
     public class PackagesLockFileBuilder
     {
-        private readonly int _lockFileVersion;
-
-        public PackagesLockFileBuilder(int lockFileVersion)
-        {
-            _lockFileVersion = lockFileVersion;
-        }
-
         public PackagesLockFile CreateNuGetLockFile(LockFile assetsFile)
         {
-            var lockFile = new PackagesLockFile()
-            {
-                Version = _lockFileVersion
-            };
+            var lockFile = new PackagesLockFile();
 
             var libraryLookup = assetsFile.Libraries.Where(e => e.Type == LibraryType.Package)
                 .ToDictionary(e => new PackageIdentity(e.Name, e.Version));
@@ -63,16 +54,16 @@ public PackagesLockFile CreateNuGetLockFile(LockFile assetsFile)
                     };
 
                     var framework_dep = framework?.Dependencies.FirstOrDefault(
-                        dep => PathUtility.GetStringComparerBasedOnOS().Equals(dep.Name, library.Name));
+                        dep => StringComparer.OrdinalIgnoreCase.Equals(dep.Name, library.Name));
 
                     if (framework_dep != null)
                     {
-                        dependency.Type = PackageInstallationType.Direct;
+                        dependency.Type = PackageDependencyType.Direct;
                         dependency.RequestedVersion = framework_dep.LibraryRange.VersionRange;
                     }
                     else
                     {
-                        dependency.Type = PackageInstallationType.Transitive;
+                        dependency.Type = PackageDependencyType.Transitive;
                     }
 
                     nuGettarget.Dependencies.Add(dependency);
@@ -84,7 +75,7 @@ public PackagesLockFile CreateNuGetLockFile(LockFile assetsFile)
                     {
                         Id = projectReference.Name,
                         Dependencies = projectReference.Dependencies,
-                        Type = PackageInstallationType.Project
+                        Type = PackageDependencyType.Project
                     };
 
                     nuGettarget.Dependencies.Add(dependency);
diff --git a/src/NuGet.Core/NuGet.Commands/RestoreCommand/RequestFactory/RestoreArgs.cs b/src/NuGet.Core/NuGet.Commands/RestoreCommand/RequestFactory/RestoreArgs.cs
index 65eb4ef14b8..b86a4a09927 100644
--- a/src/NuGet.Core/NuGet.Commands/RestoreCommand/RequestFactory/RestoreArgs.cs
+++ b/src/NuGet.Core/NuGet.Commands/RestoreCommand/RequestFactory/RestoreArgs.cs
@@ -62,7 +62,7 @@ public class RestoreArgs
 
         public Guid ParentId { get; set; }
 
-        public bool IsRestore { get; set; } = true;
+        public bool IsRestoreOriginalAction { get; set; } = true;
 
         // Cache directory -> ISettings
         private ConcurrentDictionary<string, ISettings> _settingsCache
@@ -230,7 +230,7 @@ public void ApplyStandardProperties(RestoreRequest request)
             request.AllowNoOp = !request.CacheContext.NoCache && AllowNoOp;
             request.HideWarningsAndErrors = HideWarningsAndErrors;
             request.ParentId = ParentId;
-            request.IsRestore = IsRestore;
+            request.IsRestoreOriginalAction = IsRestoreOriginalAction;
         }
     }
 }
diff --git a/src/NuGet.Core/NuGet.Commands/RestoreCommand/RestoreCommand.cs b/src/NuGet.Core/NuGet.Commands/RestoreCommand/RestoreCommand.cs
index 92115e99b4b..be3f7da066f 100644
--- a/src/NuGet.Core/NuGet.Commands/RestoreCommand/RestoreCommand.cs
+++ b/src/NuGet.Core/NuGet.Commands/RestoreCommand/RestoreCommand.cs
@@ -107,16 +107,14 @@ public async Task<RestoreResult> ExecuteAsync(CancellationToken token)
                 var contextForProject = CreateRemoteWalkContext(_request, _logger);
 
                 CacheFile cacheFile = null;
-                DependencyGraphSpec dgSpec = null;
+
                 using (var noOpTelemetry = TelemetryActivity.CreateTelemetryActivityWithNewOperationIdAndEvent(parentId: _operationId, eventName: RestoreNoOpInformation))
                 {
                     if (NoOpRestoreUtilities.IsNoOpSupported(_request))
                     {
                         noOpTelemetry.StartIntervalMeasure();
 
-                        dgSpec = NoOpRestoreUtilities.GetDGSpec(_request);
-
-                        var cacheFileAndStatus = EvaluateCacheFile(dgSpec);
+                        var cacheFileAndStatus = EvaluateCacheFile();
 
                         noOpTelemetry.EndIntervalMeasure(CacheFileEvaluateDuration);
 
@@ -155,34 +153,27 @@ public async Task<RestoreResult> ExecuteAsync(CancellationToken token)
                     }
                 }
 
-                var nuGetLockFilePath = PackagesLockFileUtilities.GetNuGetLockFilePath(_request.Project);
-                PackagesLockFile nuGetLockFile = null;
+                // evaluate packages.lock.json file
+                var packagesLockFilePath = PackagesLockFileUtilities.GetNuGetLockFilePath(_request.Project);
 
-                var restorePackagesWithLockFile = _request.Project.RestoreMetadata?.RestoreLockProperties.RestorePackagesWithLockFile;
+                var packagesLockFileResult = await EvaluatePackagesLockFileAsync(packagesLockFilePath, contextForProject);
 
-                if (!MSBuildStringUtility.IsTrueOrEmpty(restorePackagesWithLockFile) && File.Exists(nuGetLockFilePath))
-                {
-                    _success = false;
+                // result of packages.lock.json file evaluation where
+                // Item1 is the status of evaluating packages lock file if false, then bail restore
+                // Item2 is also a tuple which has 2 parts -
+                    // Item1 tells whether lock file is still valid to be consumed for this restore
+                    // Item2 is the PackagesLockFile instance
+                var result = packagesLockFileResult.Item1;
+                var isLockFileValid = packagesLockFileResult.Item2.Item1;
+                var packagesLockFile = packagesLockFileResult.Item2.Item2;
 
-                    // invalid input since packages.lock.json file exists along with RestorePackagesWithLockFile is set to false.
-                    var message = string.Format(CultureInfo.CurrentCulture, Strings.Error_InvalidLockFileInput, nuGetLockFilePath);
-                    await _logger.LogAsync(RestoreLogMessage.CreateError(NuGetLogCode.NU1005, message));
+                if (!result)
+                {
+                    _success = result;
 
                     // Replay Warnings and Errors from an existing lock file
                     await MSBuildRestoreUtility.ReplayWarningsAndErrorsAsync(_request.ExistingLockFile, _logger);
 
-                    // Write the logs into the assets file
-                    var logs = _logger.Errors
-                        .Select(l => AssetsLogMessage.Create(l))
-                        .ToList();
-
-                    LockFile newAssetsFile = null;
-                    if (_request.ExistingLockFile != null)
-                    {
-                        newAssetsFile = _request.ExistingLockFile.Clone();
-                        newAssetsFile.LogMessages = logs;
-                    }
-
                     if (cacheFile != null)
                     {
                         cacheFile.Success = _success;
@@ -193,89 +184,17 @@ public async Task<RestoreResult> ExecuteAsync(CancellationToken token)
                         restoreGraphs: new List<RestoreTargetGraph>(),
                         compatibilityCheckResults: new List<CompatibilityCheckResult>(),
                         msbuildFiles: new List<MSBuildOutputFile>(),
-                        lockFile: newAssetsFile,
+                        lockFile: _request.ExistingLockFile,
                         previousLockFile: _request.ExistingLockFile,
                         lockFilePath: _request.ExistingLockFile?.Path,
                         cacheFile: cacheFile,
                         cacheFilePath: _request.Project.RestoreMetadata.CacheFilePath,
-                        packagesLockFilePath: nuGetLockFilePath,
-                        packagesLockFile: nuGetLockFile,
+                        packagesLockFilePath: packagesLockFilePath,
+                        packagesLockFile: packagesLockFile,
                         projectStyle: _request.ProjectStyle,
                         elapsedTime: restoreTime.Elapsed);
                 }
 
-                var isLockFileValid = false;
-
-                // read packages.lock.json file if exists and ReevaluateNuGetLockFile is not set to true
-                if (!_request.Project.RestoreMetadata.RestoreLockProperties.ReevaluateNuGetLockFile &&
-                    File.Exists(nuGetLockFilePath))
-                {
-                    nuGetLockFile = PackagesLockFileFormat.Read(nuGetLockFilePath, _logger);
-
-                    if (dgSpec != null && nuGetLockFile.Targets.Count > 0)
-                    {
-                        // check if lock file is out of sync with project data
-                        isLockFileValid = PackagesLockFileUtilities.IsLockFileStillValid(dgSpec, nuGetLockFile);
-
-                        if (isLockFileValid)
-                        {
-                            // pass lock file details down to generate restore graph
-                            foreach (var target in nuGetLockFile.Targets)
-                            {
-                                var libraries = target.Dependencies
-                                    .Where(dep => dep.Type != PackageInstallationType.Project)
-                                    .Select(dep => new LibraryIdentity(dep.Id, dep.ResolvedVersion, LibraryType.Package))
-                                    .ToList();
-
-                                // add lock file libraries into RemoteWalkContext so that it can be used during restore graph generation
-                                contextForProject.LockFileLibraries.Add(new LockFileCacheKey(target.TargetFramework, target.RuntimeIdentifier), libraries);
-                            }
-                        }
-                        else if (_request.IsRestore && _request.Project.RestoreMetadata.RestoreLockProperties.RestoreLockedMode)
-                        {
-                            // bail restore since it's the locked mode but required to update the lock file.
-                            _success = false;
-                            await _logger.LogAsync(RestoreLogMessage.CreateError(NuGetLogCode.NU1004, Strings.Error_RestoreInLockedMode));
-
-                            // Replay Warnings and Errors from an existing lock file
-                            await MSBuildRestoreUtility.ReplayWarningsAndErrorsAsync(_request.ExistingLockFile, _logger);
-
-                            // Write the logs into the assets file
-                            var logs = _logger.Errors
-                                .Select(l => AssetsLogMessage.Create(l))
-                                .ToList();
-
-                            LockFile newAssetsFile = null;
-
-                            if (_request.ExistingLockFile != null)
-                            {
-                                newAssetsFile = _request.ExistingLockFile.Clone();
-                                newAssetsFile.LogMessages = logs;
-                            }
-
-                            if (cacheFile != null)
-                            {
-                                cacheFile.Success = _success;
-                            }
-
-                            return new RestoreResult(
-                                success: _success,
-                                restoreGraphs: new List<RestoreTargetGraph>(),
-                                compatibilityCheckResults: new List<CompatibilityCheckResult>(),
-                                msbuildFiles: new List<MSBuildOutputFile>(),
-                                lockFile: newAssetsFile,
-                                previousLockFile: _request.ExistingLockFile,
-                                lockFilePath: _request.ExistingLockFile?.Path,
-                                cacheFile: cacheFile,
-                                cacheFilePath: _request.Project.RestoreMetadata.CacheFilePath,
-                                packagesLockFilePath: nuGetLockFilePath,
-                                packagesLockFile: null,
-                                projectStyle: _request.ProjectStyle,
-                                elapsedTime: restoreTime.Elapsed);
-                        }
-                    }
-                }
-
                 IEnumerable<RestoreTargetGraph> graphs = null;
                 using (var restoreGraphTelemetry = TelemetryActivity.CreateTelemetryActivityWithNewOperationIdAndEvent(parentId: _operationId, eventName: GenerateRestoreGraph))
                 {
@@ -365,15 +284,15 @@ public async Task<RestoreResult> ExecuteAsync(CancellationToken token)
                     if (isLockFileValid)
                     {
                         // validate package's SHA512
-                        _success &= ValidatePackagesSha(nuGetLockFile, assetsFile);
+                        _success &= ValidatePackagesSha(packagesLockFile, assetsFile);
 
                         // clear out the existing lock file so that we don't over-write the same file
-                        nuGetLockFile = null;
+                        packagesLockFile = null;
                     }
                     else if (PackagesLockFileUtilities.IsNuGetLockFileSupported(_request.Project))
                     {
                         // generate packages.lock.json file if enabled
-                        nuGetLockFile = new PackagesLockFileBuilder(PackagesLockFileFormat.Version)
+                        packagesLockFile = new PackagesLockFileBuilder()
                             .CreateNuGetLockFile(assetsFile);
                     }
 
@@ -420,8 +339,8 @@ public async Task<RestoreResult> ExecuteAsync(CancellationToken token)
                     assetsFilePath,
                     cacheFile,
                     cacheFilePath,
-                    nuGetLockFilePath,
-                    nuGetLockFile,
+                    packagesLockFilePath,
+                    packagesLockFile,
                     _request.ProjectStyle,
                     restoreTime.Elapsed);
             }
@@ -462,7 +381,7 @@ private bool VerifyAssetsFileMatchesProject()
         private bool ValidatePackagesSha(PackagesLockFile lockFile, LockFile assetsFile)
         {
             var librariesLookUp = lockFile.Targets
-                .SelectMany(t => t.Dependencies.Where(dep => dep.Type != PackageInstallationType.Project))
+                .SelectMany(t => t.Dependencies.Where(dep => dep.Type != PackageDependencyType.Project))
                 .Distinct(new LockFileDependencyIdVersionComparer())
                 .ToDictionary(dep => new PackageIdentity(dep.Id, dep.ResolvedVersion), val => val.Sha512);
 
@@ -483,12 +402,80 @@ private bool ValidatePackagesSha(PackagesLockFile lockFile, LockFile assetsFile)
             return true;
         }
 
-        private KeyValuePair<CacheFile, bool> EvaluateCacheFile(DependencyGraphSpec dgSpec)
+        /// <summary>
+        /// Evaluate packages.lock.json file if available and accordingly return result.
+        /// </summary>
+        /// <param name="packagesLockFilePath"></param>
+        /// <param name="contextForProject"></param>
+        /// <returns>result of packages.lock.json file evaluation where
+        /// Item1 is the status of evaluating packages lock file if false, then bail restore
+        /// Item2 is also a tuple which has 2 parts -
+        ///     Item1 tells whether lock file is still valid to be consumed for this restore
+        ///     Item2 is the PackagesLockFile instance
+        /// </returns>
+        private async Task<Tuple<bool, Tuple<bool, PackagesLockFile>>> EvaluatePackagesLockFileAsync(string packagesLockFilePath, RemoteWalkContext contextForProject)
+        {
+            PackagesLockFile packagesLockFile = null;
+            var isLockFileValid = false;
+            var success = true;
+
+            var restorePackagesWithLockFile = _request.Project.RestoreMetadata?.RestoreLockProperties.RestorePackagesWithLockFile;
+
+            if (!MSBuildStringUtility.IsTrueOrEmpty(restorePackagesWithLockFile) && File.Exists(packagesLockFilePath))
+            {
+                success = false;
+
+                // invalid input since packages.lock.json file exists along with RestorePackagesWithLockFile is set to false.
+                var message = string.Format(CultureInfo.CurrentCulture, Strings.Error_InvalidLockFileInput, packagesLockFilePath);
+                await _logger.LogAsync(RestoreLogMessage.CreateError(NuGetLogCode.NU1005, message));
+
+                return Tuple.Create(success, Tuple.Create(isLockFileValid, packagesLockFile));
+            }
+
+            // read packages.lock.json file if exists and ReevaluateNuGetLockFile is not set to true
+            if (!_request.Project.RestoreMetadata.RestoreLockProperties.ReevaluateNuGetLockFile &&
+                File.Exists(packagesLockFilePath))
+            {
+                packagesLockFile = PackagesLockFileFormat.Read(packagesLockFilePath, _logger);
+
+                if (_request.DependencyGraphSpec != null && packagesLockFile.Targets.Count > 0)
+                {
+                    // check if lock file is out of sync with project data
+                    isLockFileValid = PackagesLockFileUtilities.IsLockFileStillValid(_request.DependencyGraphSpec, packagesLockFile);
+
+                    if (isLockFileValid)
+                    {
+                        // pass lock file details down to generate restore graph
+                        foreach (var target in packagesLockFile.Targets)
+                        {
+                            var libraries = target.Dependencies
+                                .Where(dep => dep.Type != PackageDependencyType.Project)
+                                .Select(dep => new LibraryIdentity(dep.Id, dep.ResolvedVersion, LibraryType.Package))
+                                .ToList();
+
+                            // add lock file libraries into RemoteWalkContext so that it can be used during restore graph generation
+                            contextForProject.LockFileLibraries.Add(new LockFileCacheKey(target.TargetFramework, target.RuntimeIdentifier), libraries);
+                        }
+                    }
+                    else if (_request.IsRestoreOriginalAction && _request.Project.RestoreMetadata.RestoreLockProperties.RestoreLockedMode)
+                    {
+                        success = false;
+
+                        // bail restore since it's the locked mode but required to update the lock file.
+                        await _logger.LogAsync(RestoreLogMessage.CreateError(NuGetLogCode.NU1004, Strings.Error_RestoreInLockedMode));
+                    }
+                }
+            }
+
+            return Tuple.Create(success, Tuple.Create(isLockFileValid, packagesLockFile));
+        }
+
+        private KeyValuePair<CacheFile, bool> EvaluateCacheFile()
         {
             CacheFile cacheFile;
             var noOp = false;
 
-            var newDgSpecHash = dgSpec.GetHash();
+            var newDgSpecHash = NoOpRestoreUtilities.GetHash(_request);
 
             if (_request.ProjectStyle == ProjectStyle.DotnetCliTool && _request.AllowNoOp)
             {
@@ -496,7 +483,11 @@ private bool ValidatePackagesSha(PackagesLockFile lockFile, LockFile assetsFile)
                 NoOpRestoreUtilities.UpdateRequestBestMatchingToolPathsIfAvailable(_request);
             }
 
-            if (_request.AllowNoOp && File.Exists(_request.Project.RestoreMetadata.CacheFilePath))
+            // if --reevaluate flag is passed then restore noop check will also be skipped.
+            // this will also help us to get rid of -force flag in near future.
+            if (_request.AllowNoOp &&
+                !_request.Project.RestoreMetadata.RestoreLockProperties.ReevaluateNuGetLockFile &&
+                File.Exists(_request.Project.RestoreMetadata.CacheFilePath))
             {
                 cacheFile = FileUtility.SafeRead(_request.Project.RestoreMetadata.CacheFilePath, (stream, path) => CacheFileFormat.Read(stream, _logger, path));
 
diff --git a/src/NuGet.Core/NuGet.Commands/RestoreCommand/RestoreRequest.cs b/src/NuGet.Core/NuGet.Commands/RestoreCommand/RestoreRequest.cs
index 5bfdd2dd199..7de9a1d75d8 100644
--- a/src/NuGet.Core/NuGet.Commands/RestoreCommand/RestoreRequest.cs
+++ b/src/NuGet.Core/NuGet.Commands/RestoreCommand/RestoreRequest.cs
@@ -164,6 +164,6 @@ public class RestoreRequest
 
         public Guid ParentId { get; set;}
 
-        public bool IsRestore { get; set; } = true;
+        public bool IsRestoreOriginalAction { get; set; } = true;
     }
 }
diff --git a/src/NuGet.Core/NuGet.Commands/RestoreCommand/Utility/NoOpRestoreUtilities.cs b/src/NuGet.Core/NuGet.Commands/RestoreCommand/Utility/NoOpRestoreUtilities.cs
index e05d75a1332..4ece4892bdb 100644
--- a/src/NuGet.Core/NuGet.Commands/RestoreCommand/Utility/NoOpRestoreUtilities.cs
+++ b/src/NuGet.Core/NuGet.Commands/RestoreCommand/Utility/NoOpRestoreUtilities.cs
@@ -196,7 +196,7 @@ public static bool VerifyPackagesOnDisk(RestoreRequest request)
         /// This methods handles the deduping of tools
         /// Handles the ignoring of RestoreSettings
         /// </summary>
-        public static DependencyGraphSpec GetDGSpec(RestoreRequest request)
+        public static string GetHash(RestoreRequest request)
         {
             if (request.Project.RestoreMetadata.ProjectStyle == ProjectStyle.DotnetCliTool || request.Project.RestoreMetadata.ProjectStyle == ProjectStyle.PackageReference)
             {
@@ -222,11 +222,11 @@ public static DependencyGraphSpec GetDGSpec(RestoreRequest request)
                 }
 
                 PersistHashedDGFileIfDebugging(dgSpec, request.Log);
-                return dgSpec;
+                return dgSpec.GetHash();
             }
 
             PersistHashedDGFileIfDebugging(request.DependencyGraphSpec, request.Log);
-            return request.DependencyGraphSpec;
+            return request.DependencyGraphSpec.GetHash();
         }
 
 
diff --git a/src/NuGet.Core/NuGet.DependencyResolver.Core/ResolverUtility.cs b/src/NuGet.Core/NuGet.DependencyResolver.Core/ResolverUtility.cs
index 7663799530f..3b8c38dd6e6 100644
--- a/src/NuGet.Core/NuGet.DependencyResolver.Core/ResolverUtility.cs
+++ b/src/NuGet.Core/NuGet.DependencyResolver.Core/ResolverUtility.cs
@@ -204,7 +204,7 @@ public static GraphItem<RemoteResolveResult> CreateUnresolvedMatch(LibraryRange
             // This is only applicable when packages has to be resolved from packages.lock.json file
             if (lockFileLibraries.TryGetValue(key, out var libraries))
             {
-                var library = libraries.FirstOrDefault(lib => PathUtility.GetStringComparerBasedOnOS().Equals(lib.Name, libraryRange.Name));
+                var library = libraries.FirstOrDefault(lib => StringComparer.OrdinalIgnoreCase.Equals(lib.Name, libraryRange.Name));
 
                 if (library != null)
                 {
diff --git a/src/NuGet.Core/NuGet.PackageManagement/BuildIntegration/DependencyGraphRestoreUtility.cs b/src/NuGet.Core/NuGet.PackageManagement/BuildIntegration/DependencyGraphRestoreUtility.cs
index ad169aeacee..9884c0b6dff 100644
--- a/src/NuGet.Core/NuGet.PackageManagement/BuildIntegration/DependencyGraphRestoreUtility.cs
+++ b/src/NuGet.Core/NuGet.PackageManagement/BuildIntegration/DependencyGraphRestoreUtility.cs
@@ -30,13 +30,14 @@ public static class DependencyGraphRestoreUtility
         /// </summary>
         public static async Task<IReadOnlyList<RestoreSummary>> RestoreAsync(
             ISolutionManager solutionManager,
+            DependencyGraphSpec dgSpec,
             DependencyGraphCacheContext context,
             RestoreCommandProvidersCache providerCache,
             Action<SourceCacheContext> cacheContextModifier,
             IEnumerable<SourceRepository> sources,
             Guid parentId,
             bool forceRestore,
-            DependencyGraphSpec dgSpec,
+            bool isRestoreOriginalAction,
             ILogger log,
             CancellationToken token)
         {
@@ -56,7 +57,7 @@ public static class DependencyGraphRestoreUtility
                         dgSpec,
                         parentId,
                         forceRestore,
-                        isRestore: true);
+                        isRestoreOriginalAction);
 
                     var restoreSummaries = await RestoreRunner.RunAsync(restoreContext, token);
 
@@ -71,49 +72,6 @@ public static class DependencyGraphRestoreUtility
             return new List<RestoreSummary>();
         }
 
-        /// <summary>
-        /// Restore a dg spec. This will not update the context cache.
-        /// </summary>
-        public static async Task<IReadOnlyList<RestoreSummary>> RestoreAsync(
-            DependencyGraphSpec dgSpec,
-            DependencyGraphCacheContext context,
-            RestoreCommandProvidersCache providerCache,
-            Action<SourceCacheContext> cacheContextModifier,
-            IEnumerable<SourceRepository> sources,
-            Guid parentId,
-            bool forceRestore,
-            ILogger log,
-            CancellationToken token)
-        {
-            // Check if there are actual projects to restore before running.
-            if (dgSpec.Restore.Count > 0)
-            {
-                using (var sourceCacheContext = new SourceCacheContext())
-                {
-                    // Update cache context
-                    cacheContextModifier(sourceCacheContext);
-
-                    var restoreContext = GetRestoreContext(
-                        context,
-                        providerCache,
-                        sourceCacheContext,
-                        sources,
-                        dgSpec,
-                        parentId,
-                        forceRestore: forceRestore,
-                        isRestore: false);
-
-                    var restoreSummaries = await RestoreRunner.RunAsync(restoreContext, token);
-
-                    RestoreSummary.Log(log, restoreSummaries);
-
-                    return restoreSummaries;
-                }
-            }
-
-            return new List<RestoreSummary>();
-        }
-
         private static async Task PersistDGSpec(DependencyGraphSpec dgSpec)
         {
             try
@@ -176,7 +134,7 @@ private static async Task PersistDGSpec(DependencyGraphSpec dgSpec)
                     dgFile,
                     parentId,
                     forceRestore: true,
-                    isRestore: false);
+                    isRestoreOriginalAction: false);
 
                 var requests = await RestoreRunner.GetRequests(restoreContext);
                 var results = await RestoreRunner.RunWithoutCommit(requests, restoreContext);
@@ -289,7 +247,7 @@ public static async Task<PackageSpec> GetProjectSpec(IDependencyGraphProject pro
             DependencyGraphSpec dgFile,
             Guid parentId,
             bool forceRestore,
-            bool isRestore)
+            bool isRestoreOriginalAction)
         {
             var caching = new CachingSourceProvider(new PackageSourceProvider(context.Settings));
             foreach( var source in sources)
@@ -307,7 +265,7 @@ public static async Task<PackageSpec> GetProjectSpec(IDependencyGraphProject pro
                 AllowNoOp = !forceRestore,
                 CachingSourceProvider = caching,
                 ParentId = parentId,
-                IsRestore = isRestore
+                IsRestoreOriginalAction = isRestoreOriginalAction
             };
 
             return restoreContext;
diff --git a/src/NuGet.Core/NuGet.PackageManagement/NuGetPackageManager.cs b/src/NuGet.Core/NuGet.PackageManagement/NuGetPackageManager.cs
index 91c4a32856f..d4c78551949 100644
--- a/src/NuGet.Core/NuGet.PackageManagement/NuGetPackageManager.cs
+++ b/src/NuGet.Core/NuGet.PackageManagement/NuGetPackageManager.cs
@@ -2892,15 +2892,17 @@ var projectUniqueNamesForBuildIntToUpdate
                     // Restore and commit the lock file to disk regardless of the result
                     // This will restore all parents in a single restore 
                     await DependencyGraphRestoreUtility.RestoreAsync(
+                        SolutionManager,
                         dgSpecForParents,
                         referenceContext,
                         GetRestoreProviderCache(),
                         cacheContextModifier,
                         projectAction.Sources,
                         nuGetProjectContext.OperationId,
-                        false, // No need to force restore as the inputs would've changed here anyways
-                        logger,
-                        token);
+                        forceRestore: false, // No need to force restore as the inputs would've changed here anyways
+                        isRestoreOriginalAction: false, // not an explicit restore request instead being done as part of install or update
+                        log: logger,
+                        token: token);
                 }
             }
             else
diff --git a/src/NuGet.Core/NuGet.ProjectModel/JsonUtility.cs b/src/NuGet.Core/NuGet.ProjectModel/JsonUtility.cs
index d43cecdd080..f1d0af8bb21 100644
--- a/src/NuGet.Core/NuGet.ProjectModel/JsonUtility.cs
+++ b/src/NuGet.Core/NuGet.ProjectModel/JsonUtility.cs
@@ -1,14 +1,20 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
 
+using System;
+using System.Collections.Generic;
 using System.IO;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using NuGet.Packaging.Core;
+using NuGet.Versioning;
 
 namespace NuGet.ProjectModel
 {
     internal static class JsonUtility
     {
+        internal static readonly char[] PathSplitChars = new[] { LockFile.DirectorySeparatorChar };
+
         /// <summary>
         /// JsonLoadSettings with line info and comments ignored.
         /// </summary>
@@ -36,5 +42,73 @@ internal static JObject LoadJson(TextReader reader)
                 return JObject.Load(jsonReader, DefaultLoadSettings);
             }
         }
+
+        internal static PackageDependency ReadPackageDependency(string property, JToken json)
+        {
+            var versionStr = json.Value<string>();
+            return new PackageDependency(
+                property,
+                versionStr == null ? null : VersionRange.Parse(versionStr));
+        }
+
+        internal static JProperty WritePackageDependency(PackageDependency item)
+        {
+            return new JProperty(
+                item.Id,
+                WriteString(item.VersionRange?.ToLegacyShortString()));
+        }
+
+        internal static TItem ReadProperty<TItem>(JObject jObject, string propertyName)
+        {
+            if (jObject != null)
+            {
+                JToken value;
+                if (jObject.TryGetValue(propertyName, out value) && value != null)
+                {
+                    return value.Value<TItem>();
+                }
+            }
+
+            return default(TItem);
+        }
+
+        internal static IList<TItem> ReadObject<TItem>(JObject jObject, Func<string, JToken, TItem> readItem)
+        {
+            if (jObject == null)
+            {
+                return new List<TItem>();
+            }
+            var items = new List<TItem>();
+            foreach (var child in jObject)
+            {
+                items.Add(readItem(child.Key, child.Value));
+            }
+            return items;
+        }
+
+        internal static JObject WriteObject<TItem>(IEnumerable<TItem> items, Func<TItem, JProperty> writeItem)
+        {
+            var array = new JObject();
+            foreach (var item in items)
+            {
+                array.Add(writeItem(item));
+            }
+            return array;
+        }
+
+        internal static int ReadInt(JToken cursor, string property, int defaultValue)
+        {
+            var valueToken = cursor[property];
+            if (valueToken == null)
+            {
+                return defaultValue;
+            }
+            return valueToken.Value<int>();
+        }
+
+        internal static JToken WriteString(string item)
+        {
+            return item != null ? new JValue(item) : JValue.CreateNull();
+        }
     }
 }
diff --git a/src/NuGet.Core/NuGet.ProjectModel/LockFile/LockFile.cs b/src/NuGet.Core/NuGet.ProjectModel/LockFile/LockFile.cs
index 95bb0764dcc..de240cbb2d9 100644
--- a/src/NuGet.Core/NuGet.ProjectModel/LockFile/LockFile.cs
+++ b/src/NuGet.Core/NuGet.ProjectModel/LockFile/LockFile.cs
@@ -132,21 +132,6 @@ public bool Equals(LockFile other)
                 && LogsEqual(other.LogMessages);
         }
 
-        public LockFile Clone()
-        {
-            var lockFile = new LockFile();
-            lockFile.Version = Version;
-            lockFile.Path = Path;
-            lockFile.ProjectFileDependencyGroups = ProjectFileDependencyGroups?.Select(item => item.Clone()).ToList();
-            lockFile.Libraries = Libraries?.Select(item => item.Clone()).ToList();
-            lockFile.Targets = Targets?.Select(item => item.Clone()).ToList();
-            lockFile.PackageFolders = new List<LockFileItem>(PackageFolders);
-            lockFile.PackageSpec = PackageSpec.Clone();
-            lockFile.LogMessages = new List<IAssetsLogMessage>(LogMessages);
-
-            return lockFile;
-        }
-
         private bool LogsEqual(IList<IAssetsLogMessage> otherLogMessages)
         {
             if (ReferenceEquals(LogMessages, otherLogMessages))
diff --git a/src/NuGet.Core/NuGet.ProjectModel/LockFile/LockFileFormat.cs b/src/NuGet.Core/NuGet.ProjectModel/LockFile/LockFileFormat.cs
index 1edaa2d2ca8..e47971b9d60 100644
--- a/src/NuGet.Core/NuGet.ProjectModel/LockFile/LockFileFormat.cs
+++ b/src/NuGet.Core/NuGet.ProjectModel/LockFile/LockFileFormat.cs
@@ -23,8 +23,6 @@ public class LockFileFormat
         public static readonly string LockFileName = "project.lock.json";
         public static readonly string AssetsFileName = "project.assets.json";
 
-        internal static readonly char[] PathSplitChars = new[] { LockFile.DirectorySeparatorChar };
-
         private const string VersionProperty = "version";
         private const string LibrariesProperty = "libraries";
         private const string TargetsProperty = "targets";
@@ -168,11 +166,11 @@ private static LockFile ReadLockFile(JObject cursor)
         {
             var lockFile = new LockFile()
             {
-                Version = ReadInt(cursor, VersionProperty, defaultValue: int.MinValue),
-                Libraries = ReadObject(cursor[LibrariesProperty] as JObject, ReadLibrary),
-                Targets = ReadObject(cursor[TargetsProperty] as JObject, ReadTarget),
-                ProjectFileDependencyGroups = ReadObject(cursor[ProjectFileDependencyGroupsProperty] as JObject, ReadProjectFileDependencyGroup),
-                PackageFolders = ReadObject(cursor[PackageFoldersProperty] as JObject, ReadFileItem),
+                Version = JsonUtility.ReadInt(cursor, VersionProperty, defaultValue: int.MinValue),
+                Libraries = JsonUtility.ReadObject(cursor[LibrariesProperty] as JObject, ReadLibrary),
+                Targets = JsonUtility.ReadObject(cursor[TargetsProperty] as JObject, ReadTarget),
+                ProjectFileDependencyGroups = JsonUtility.ReadObject(cursor[ProjectFileDependencyGroupsProperty] as JObject, ReadProjectFileDependencyGroup),
+                PackageFolders = JsonUtility.ReadObject(cursor[PackageFoldersProperty] as JObject, ReadFileItem),
                 PackageSpec = ReadPackageSpec(cursor[PackageSpecProperty] as JObject)
             };
 
@@ -187,13 +185,13 @@ private static JObject WriteLockFile(LockFile lockFile)
             var json = new JObject
             {
                 [VersionProperty] = new JValue(lockFile.Version),
-                [TargetsProperty] = WriteObject(lockFile.Targets, WriteTarget),
-                [LibrariesProperty] = WriteObject(lockFile.Libraries, WriteLibrary),
-                [ProjectFileDependencyGroupsProperty] = WriteObject(lockFile.ProjectFileDependencyGroups, WriteProjectFileDependencyGroup)
+                [TargetsProperty] = JsonUtility.WriteObject(lockFile.Targets, WriteTarget),
+                [LibrariesProperty] = JsonUtility.WriteObject(lockFile.Libraries, WriteLibrary),
+                [ProjectFileDependencyGroupsProperty] = JsonUtility.WriteObject(lockFile.ProjectFileDependencyGroups, WriteProjectFileDependencyGroup)
             };
             if (lockFile.PackageFolders?.Any() == true)
             {
-                json[PackageFoldersProperty] = WriteObject(lockFile.PackageFolders, WriteFileItem);
+                json[PackageFoldersProperty] = JsonUtility.WriteObject(lockFile.PackageFolders, WriteFileItem);
             }
 
             if (lockFile.Version >= 2)
@@ -233,9 +231,9 @@ private static LockFileLibrary ReadLibrary(string property, JToken json)
 
             var jObject = json as JObject;
 
-            library.Path = ReadProperty<string>(jObject, PathProperty);
-            library.MSBuildProject = ReadProperty<string>(jObject, MSBuildProjectProperty);
-            library.Sha512 = ReadProperty<string>(jObject, Sha512Property);
+            library.Path = JsonUtility.ReadProperty<string>(jObject, PathProperty);
+            library.MSBuildProject = JsonUtility.ReadProperty<string>(jObject, MSBuildProjectProperty);
+            library.Sha512 = JsonUtility.ReadProperty<string>(jObject, Sha512Property);
 
             library.IsServiceable = ReadBool(json, ServicableProperty, defaultValue: false);
             library.Files = ReadPathArray(json[FilesProperty] as JArray, ReadString);
@@ -253,22 +251,22 @@ private static JProperty WriteLibrary(LockFileLibrary library)
 
             if (library.Sha512 != null)
             {
-                json[Sha512Property] = WriteString(library.Sha512);
+                json[Sha512Property] = JsonUtility.WriteString(library.Sha512);
             }
 
-            json[TypeProperty] = WriteString(library.Type);
+            json[TypeProperty] = JsonUtility.WriteString(library.Type);
 
             if (library.Path != null)
             {
-                json[PathProperty] = WriteString(library.Path);
+                json[PathProperty] = JsonUtility.WriteString(library.Path);
             }
 
             if (library.MSBuildProject != null)
             {
-                json[MSBuildProjectProperty] = WriteString(library.MSBuildProject);
+                json[MSBuildProjectProperty] = JsonUtility.WriteString(library.MSBuildProject);
             }
 
-            WritePathArray(json, FilesProperty, library.Files, WriteString);
+            WritePathArray(json, FilesProperty, library.Files, JsonUtility.WriteString);
             return new JProperty(
                 library.Name + "/" + library.Version.ToNormalizedString(),
                 json);
@@ -276,7 +274,7 @@ private static JProperty WriteLibrary(LockFileLibrary library)
 
         private static JProperty WriteTarget(LockFileTarget target)
         {
-            var json = WriteObject(target.Libraries, WriteTargetLibrary);
+            var json = JsonUtility.WriteObject(target.Libraries, WriteTargetLibrary);
 
             var key = target.Name;
 
@@ -286,14 +284,14 @@ private static JProperty WriteTarget(LockFileTarget target)
         private static LockFileTarget ReadTarget(string property, JToken json)
         {
             var target = new LockFileTarget();
-            var parts = property.Split(PathSplitChars, 2);
+            var parts = property.Split(JsonUtility.PathSplitChars, 2);
             target.TargetFramework = NuGetFramework.Parse(parts[0]);
             if (parts.Length == 2)
             {
                 target.RuntimeIdentifier = parts[1];
             }
 
-            target.Libraries = ReadObject(json as JObject, ReadTargetLibrary);
+            target.Libraries = JsonUtility.ReadObject(json as JObject, ReadTargetLibrary);
 
             return target;
         }
@@ -465,20 +463,20 @@ private static LockFileTargetLibrary ReadTargetLibrary(string property, JToken j
             }
 
             var jObject = json as JObject;
-            library.Type = ReadProperty<string>(jObject, TypeProperty);
-            library.Framework = ReadProperty<string>(jObject, FrameworkProperty);
+            library.Type = JsonUtility.ReadProperty<string>(jObject, TypeProperty);
+            library.Framework = JsonUtility.ReadProperty<string>(jObject, FrameworkProperty);
 
-            library.Dependencies = ReadObject(json[DependenciesProperty] as JObject, ReadPackageDependency);
+            library.Dependencies = JsonUtility.ReadObject(json[DependenciesProperty] as JObject, JsonUtility.ReadPackageDependency);
             library.FrameworkAssemblies = ReadArray(json[FrameworkAssembliesProperty] as JArray, ReadString);
-            library.RuntimeAssemblies = ReadObject(json[RuntimeProperty] as JObject, ReadFileItem);
-            library.CompileTimeAssemblies = ReadObject(json[CompileProperty] as JObject, ReadFileItem);
-            library.ResourceAssemblies = ReadObject(json[ResourceProperty] as JObject, ReadFileItem);
-            library.NativeLibraries = ReadObject(json[NativeProperty] as JObject, ReadFileItem);
-            library.Build = ReadObject(json[BuildProperty] as JObject, ReadFileItem);
-            library.BuildMultiTargeting = ReadObject(json[BuildMultiTargetingProperty] as JObject, ReadFileItem);
-            library.ContentFiles = ReadObject(json[ContentFilesProperty] as JObject, ReadContentFile);
-            library.RuntimeTargets = ReadObject(json[RuntimeTargetsProperty] as JObject, ReadRuntimeTarget);
-            library.ToolsAssemblies = ReadObject(json[ToolsProperty] as JObject, ReadFileItem);
+            library.RuntimeAssemblies = JsonUtility.ReadObject(json[RuntimeProperty] as JObject, ReadFileItem);
+            library.CompileTimeAssemblies = JsonUtility.ReadObject(json[CompileProperty] as JObject, ReadFileItem);
+            library.ResourceAssemblies = JsonUtility.ReadObject(json[ResourceProperty] as JObject, ReadFileItem);
+            library.NativeLibraries = JsonUtility.ReadObject(json[NativeProperty] as JObject, ReadFileItem);
+            library.Build = JsonUtility.ReadObject(json[BuildProperty] as JObject, ReadFileItem);
+            library.BuildMultiTargeting = JsonUtility.ReadObject(json[BuildMultiTargetingProperty] as JObject, ReadFileItem);
+            library.ContentFiles = JsonUtility.ReadObject(json[ContentFilesProperty] as JObject, ReadContentFile);
+            library.RuntimeTargets = JsonUtility.ReadObject(json[RuntimeTargetsProperty] as JObject, ReadRuntimeTarget);
+            library.ToolsAssemblies = JsonUtility.ReadObject(json[ToolsProperty] as JObject, ReadFileItem);
 
             return library;
         }
@@ -501,77 +499,77 @@ private static JProperty WriteTargetLibrary(LockFileTargetLibrary library)
             {
                 var ordered = library.Dependencies.OrderBy(dependency => dependency.Id, StringComparer.Ordinal);
 
-                json[DependenciesProperty] = WriteObject(ordered, WritePackageDependency);
+                json[DependenciesProperty] = JsonUtility.WriteObject(ordered, JsonUtility.WritePackageDependency);
             }
 
             if (library.FrameworkAssemblies.Count > 0)
             {
                 var ordered = library.FrameworkAssemblies.OrderBy(assembly => assembly, StringComparer.Ordinal);
 
-                json[FrameworkAssembliesProperty] = WriteArray(ordered, WriteString);
+                json[FrameworkAssembliesProperty] = WriteArray(ordered, JsonUtility.WriteString);
             }
 
             if (library.CompileTimeAssemblies.Count > 0)
             {
                 var ordered = library.CompileTimeAssemblies.OrderBy(assembly => assembly.Path, StringComparer.Ordinal);
 
-                json[CompileProperty] = WriteObject(ordered, WriteFileItem);
+                json[CompileProperty] = JsonUtility.WriteObject(ordered, WriteFileItem);
             }
 
             if (library.RuntimeAssemblies.Count > 0)
             {
                 var ordered = library.RuntimeAssemblies.OrderBy(assembly => assembly.Path, StringComparer.Ordinal);
 
-                json[RuntimeProperty] = WriteObject(ordered, WriteFileItem);
+                json[RuntimeProperty] = JsonUtility.WriteObject(ordered, WriteFileItem);
             }
 
             if (library.ResourceAssemblies.Count > 0)
             {
                 var ordered = library.ResourceAssemblies.OrderBy(assembly => assembly.Path, StringComparer.Ordinal);
 
-                json[ResourceProperty] = WriteObject(ordered, WriteFileItem);
+                json[ResourceProperty] = JsonUtility.WriteObject(ordered, WriteFileItem);
             }
 
             if (library.NativeLibraries.Count > 0)
             {
                 var ordered = library.NativeLibraries.OrderBy(assembly => assembly.Path, StringComparer.Ordinal);
 
-                json[NativeProperty] = WriteObject(ordered, WriteFileItem);
+                json[NativeProperty] = JsonUtility.WriteObject(ordered, WriteFileItem);
             }
 
             if (library.ContentFiles.Count > 0)
             {
                 var ordered = library.ContentFiles.OrderBy(assembly => assembly.Path, StringComparer.Ordinal);
 
-                json[ContentFilesProperty] = WriteObject(ordered, WriteFileItem);
+                json[ContentFilesProperty] = JsonUtility.WriteObject(ordered, WriteFileItem);
             }
 
             if (library.Build.Count > 0)
             {
                 var ordered = library.Build.OrderBy(assembly => assembly.Path, StringComparer.Ordinal);
 
-                json[BuildProperty] = WriteObject(ordered, WriteFileItem);
+                json[BuildProperty] = JsonUtility.WriteObject(ordered, WriteFileItem);
             }
 
             if (library.BuildMultiTargeting.Count > 0)
             {
                 var ordered = library.BuildMultiTargeting.OrderBy(assembly => assembly.Path, StringComparer.Ordinal);
 
-                json[BuildMultiTargetingProperty] = WriteObject(ordered, WriteFileItem);
+                json[BuildMultiTargetingProperty] = JsonUtility.WriteObject(ordered, WriteFileItem);
             }
 
             if (library.RuntimeTargets.Count > 0)
             {
                 var ordered = library.RuntimeTargets.OrderBy(assembly => assembly.Path, StringComparer.Ordinal);
 
-                json[RuntimeTargetsProperty] = WriteObject(ordered, WriteFileItem);
+                json[RuntimeTargetsProperty] = JsonUtility.WriteObject(ordered, WriteFileItem);
             }
 
             if (library.ToolsAssemblies.Count > 0)
             {
                 var ordered = library.ToolsAssemblies.OrderBy(assembly => assembly.Path, StringComparer.Ordinal);
 
-                json[ToolsProperty] = WriteObject(ordered, WriteFileItem);
+                json[ToolsProperty] = JsonUtility.WriteObject(ordered, WriteFileItem);
             }
 
             return new JProperty(library.Name + "/" + library.Version.ToNormalizedString(), json);
@@ -612,7 +610,7 @@ private static JProperty WriteProjectFileDependencyGroup(ProjectFileDependencyGr
         {
             return new JProperty(
                 frameworkInfo.FrameworkName,
-                WriteArray(frameworkInfo.Dependencies, WriteString));
+                WriteArray(frameworkInfo.Dependencies, JsonUtility.WriteString));
         }
 
         private static PackageDependencyGroup ReadPackageDependencyGroup(string property, JToken json)
@@ -620,29 +618,14 @@ private static PackageDependencyGroup ReadPackageDependencyGroup(string property
             var targetFramework = string.Equals(property, "*") ? null : new NuGetFramework(property);
             return new PackageDependencyGroup(
                 targetFramework,
-                ReadObject(json as JObject, ReadPackageDependency));
+                JsonUtility.ReadObject(json as JObject, JsonUtility.ReadPackageDependency));
         }
 
         private static JProperty WritePackageDependencyGroup(PackageDependencyGroup item)
         {
             return new JProperty(
                 item.TargetFramework?.ToString() ?? "*",
-                WriteObject(item.Packages, WritePackageDependency));
-        }
-
-        internal static PackageDependency ReadPackageDependency(string property, JToken json)
-        {
-            var versionStr = json.Value<string>();
-            return new PackageDependency(
-                property,
-                versionStr == null ? null : VersionRange.Parse(versionStr));
-        }
-
-        internal static JProperty WritePackageDependency(PackageDependency item)
-        {
-            return new JProperty(
-                item.Id,
-                WriteString(item.VersionRange?.ToLegacyShortString()));
+                JsonUtility.WriteObject(item.Packages, JsonUtility.WritePackageDependency));
         }
 
         private static LockFileItem ReadFileItem(string property, JToken json)
@@ -756,50 +739,12 @@ private static JArray WritePathArray(IEnumerable<string> items, Func<string, JTo
             return WriteArray(items.Select(f => GetPathWithForwardSlashes(f)), writeItem);
         }
 
-        internal static TItem ReadProperty<TItem>(JObject jObject, string propertyName)
-        {
-            if (jObject != null)
-            {
-                JToken value;
-                if (jObject.TryGetValue(propertyName, out value) && value != null)
-                {
-                    return value.Value<TItem>();
-                }
-            }
-
-            return default(TItem);
-        }
-
-        internal static IList<TItem> ReadObject<TItem>(JObject jObject, Func<string, JToken, TItem> readItem)
-        {
-            if (jObject == null)
-            {
-                return new List<TItem>();
-            }
-            var items = new List<TItem>();
-            foreach (var child in jObject)
-            {
-                items.Add(readItem(child.Key, child.Value));
-            }
-            return items;
-        }
-
         private static void WriteObject<TItem>(JToken json, string property, IEnumerable<TItem> items, Func<TItem, JProperty> writeItem)
         {
             if (items.Any())
             {
-                json[property] = WriteObject(items, writeItem);
-            }
-        }
-
-        internal static JObject WriteObject<TItem>(IEnumerable<TItem> items, Func<TItem, JProperty> writeItem)
-        {
-            var array = new JObject();
-            foreach (var item in items)
-            {
-                array.Add(writeItem(item));
+                json[property] = JsonUtility.WriteObject(items, writeItem);
             }
-            return array;
         }
 
         private static bool ReadBool(JToken cursor, string property, bool defaultValue)
@@ -812,16 +757,6 @@ private static bool ReadBool(JToken cursor, string property, bool defaultValue)
             return valueToken.Value<bool>();
         }
 
-        internal static int ReadInt(JToken cursor, string property, int defaultValue)
-        {
-            var valueToken = cursor[property];
-            if (valueToken == null)
-            {
-                return defaultValue;
-            }
-            return valueToken.Value<int>();
-        }
-
         private static string ReadString(JToken json)
         {
             return json.Value<string>();
@@ -842,11 +777,6 @@ private static void WriteBool(JToken token, string property, bool value)
             token[property] = new JValue(value);
         }
 
-        private static JToken WriteString(string item)
-        {
-            return item != null ? new JValue(item) : JValue.CreateNull();
-        }
-
         private static NuGetFramework ReadFrameworkName(JToken json)
         {
             return json == null ? null : new NuGetFramework(json.Value<string>());
diff --git a/src/NuGet.Core/NuGet.ProjectModel/LockFile/LockFileTarget.cs b/src/NuGet.Core/NuGet.ProjectModel/LockFile/LockFileTarget.cs
index db97bd855b3..4fd2583387c 100644
--- a/src/NuGet.Core/NuGet.ProjectModel/LockFile/LockFileTarget.cs
+++ b/src/NuGet.Core/NuGet.ProjectModel/LockFile/LockFileTarget.cs
@@ -61,15 +61,5 @@ public override int GetHashCode()
 
             return combiner.CombinedHash;
         }
-
-        public LockFileTarget Clone()
-        {
-            return new LockFileTarget
-            {
-                TargetFramework = TargetFramework,
-                RuntimeIdentifier = RuntimeIdentifier,
-                Libraries = new List<LockFileTargetLibrary>(Libraries)
-            };
-        }
     }
 }
diff --git a/src/NuGet.Core/NuGet.ProjectModel/ProjectFileDependencyGroup.cs b/src/NuGet.Core/NuGet.ProjectModel/ProjectFileDependencyGroup.cs
index b20cd53165f..5936f4c6021 100644
--- a/src/NuGet.Core/NuGet.ProjectModel/ProjectFileDependencyGroup.cs
+++ b/src/NuGet.Core/NuGet.ProjectModel/ProjectFileDependencyGroup.cs
@@ -45,13 +45,6 @@ public bool Equals(ProjectFileDependencyGroup other)
             return false;
         }
 
-        public ProjectFileDependencyGroup Clone()
-        {
-            var depGroup = new ProjectFileDependencyGroup(FrameworkName, Dependencies?.Select(item => item));
-
-            return depGroup;
-        }
-
         public override bool Equals(object obj)
         {
             return Equals(obj as ProjectFileDependencyGroup);
diff --git a/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/LockFileDependency.cs b/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/LockFileDependency.cs
index 13ac48ccdce..38e5581cf6b 100644
--- a/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/LockFileDependency.cs
+++ b/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/LockFileDependency.cs
@@ -21,7 +21,7 @@ public class LockFileDependency : IEquatable<LockFileDependency>
 
         public string Sha512 { get; set; }
 
-        public PackageInstallationType Type { get; set; }
+        public PackageDependencyType Type { get; set; }
 
         public IList<PackageDependency> Dependencies { get; set; } = new List<PackageDependency>();
 
@@ -37,7 +37,7 @@ public bool Equals(LockFileDependency other)
                 return true;
             }
 
-            return PathUtility.GetStringComparerBasedOnOS().Equals(Id, other.Id) &&
+            return StringComparer.OrdinalIgnoreCase.Equals(Id, other.Id) &&
                 EqualityUtility.EqualsWithNullCheck(ResolvedVersion, other.ResolvedVersion) &&
                 EqualityUtility.EqualsWithNullCheck(RequestedVersion, other.RequestedVersion) &&
                 EqualityUtility.SequenceEqualWithNullCheck(Dependencies, other.Dependencies) &&
diff --git a/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/LockFileDependencyIdVersionComparer.cs b/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/LockFileDependencyIdVersionComparer.cs
index 20928bc54b7..a435eab63d0 100644
--- a/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/LockFileDependencyIdVersionComparer.cs
+++ b/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/LockFileDependencyIdVersionComparer.cs
@@ -21,7 +21,7 @@ public bool Equals(LockFileDependency x, LockFileDependency y)
                 return false;
             }
 
-            return PathUtility.GetStringComparerBasedOnOS().Equals(x.Id, y.Id) &&
+            return StringComparer.OrdinalIgnoreCase.Equals(x.Id, y.Id) &&
                 EqualityUtility.EqualsWithNullCheck(x.ResolvedVersion, y.ResolvedVersion);
         }
 
diff --git a/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackageInstallationType.cs b/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackageDependencyType.cs
similarity index 93%
rename from src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackageInstallationType.cs
rename to src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackageDependencyType.cs
index 455513ff64f..8ba6745c786 100644
--- a/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackageInstallationType.cs
+++ b/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackageDependencyType.cs
@@ -3,7 +3,7 @@
 
 namespace NuGet.ProjectModel
 {
-    public enum PackageInstallationType
+    public enum PackageDependencyType
     {
         /// <summary>
         /// Package is directly installed into the project.
diff --git a/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackagesLockFile.cs b/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackagesLockFile.cs
index 92c57006ae2..58d373ebc70 100644
--- a/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackagesLockFile.cs
+++ b/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackagesLockFile.cs
@@ -11,7 +11,7 @@ namespace NuGet.ProjectModel
 {
     public class PackagesLockFile : IEquatable<PackagesLockFile>
     {
-        public int Version { get; set; }
+        public int Version { get; } = PackagesLockFileFormat.Version;
 
         public string Path { get; set; }
 
diff --git a/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackagesLockFileFormat.cs b/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackagesLockFileFormat.cs
index c88f602c4c5..2c7a0db0e44 100644
--- a/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackagesLockFileFormat.cs
+++ b/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackagesLockFileFormat.cs
@@ -88,8 +88,8 @@ private static PackagesLockFile ReadLockFile(JObject cursor)
         {
             var lockFile = new PackagesLockFile()
             {
-                Version = LockFileFormat.ReadInt(cursor, VersionProperty, defaultValue: int.MinValue),
-                Targets = LockFileFormat.ReadObject(cursor[DependenciesProperty] as JObject, ReadDependency),
+                Version = JsonUtility.ReadInt(cursor, VersionProperty, defaultValue: int.MinValue),
+                Targets = JsonUtility.ReadObject(cursor[DependenciesProperty] as JObject, ReadDependency),
             };
 
             return lockFile;
@@ -140,7 +140,7 @@ private static JObject WriteLockFile(PackagesLockFile lockFile)
             var json = new JObject
             {
                 [VersionProperty] = new JValue(lockFile.Version),
-                [DependenciesProperty] = LockFileFormat.WriteObject(lockFile.Targets, WriteTarget),
+                [DependenciesProperty] = JsonUtility.WriteObject(lockFile.Targets, WriteTarget),
             };
 
             return json;
@@ -148,12 +148,12 @@ private static JObject WriteLockFile(PackagesLockFile lockFile)
 
         private static PackagesLockFileTarget ReadDependency(string property, JToken json)
         {
-            var parts = property.Split(LockFileFormat.PathSplitChars, 2);
+            var parts = property.Split(JsonUtility.PathSplitChars, 2);
 
             var target = new PackagesLockFileTarget
             {
                 TargetFramework = NuGetFramework.Parse(parts[0]),
-                Dependencies = LockFileFormat.ReadObject(json as JObject, ReadTargetDependency)
+                Dependencies = JsonUtility.ReadObject(json as JObject, ReadTargetDependency)
             };
 
             if (parts.Length == 2)
@@ -169,41 +169,41 @@ private static LockFileDependency ReadTargetDependency(string property, JToken j
             var dependency = new LockFileDependency
             {
                 Id = property,
-                Dependencies = LockFileFormat.ReadObject(json[DependenciesProperty] as JObject, LockFileFormat.ReadPackageDependency)
+                Dependencies = JsonUtility.ReadObject(json[DependenciesProperty] as JObject, JsonUtility.ReadPackageDependency)
             };
 
             var jObject = json as JObject;
 
-            var typeString = LockFileFormat.ReadProperty<string>(jObject, TypeProperty);
+            var typeString = JsonUtility.ReadProperty<string>(jObject, TypeProperty);
 
             if (!string.IsNullOrEmpty(typeString)
-                && Enum.TryParse<PackageInstallationType>(typeString, ignoreCase: true, result: out var installationType))
+                && Enum.TryParse<PackageDependencyType>(typeString, ignoreCase: true, result: out var installationType))
             {
                 dependency.Type = installationType;
             }
 
-            var resolvedString = LockFileFormat.ReadProperty<string>(jObject, ResolvedProperty);
+            var resolvedString = JsonUtility.ReadProperty<string>(jObject, ResolvedProperty);
 
             if (!string.IsNullOrEmpty(resolvedString))
             {
                 dependency.ResolvedVersion = NuGetVersion.Parse(resolvedString);
             }
 
-            var requestedString = LockFileFormat.ReadProperty<string>(jObject, RequestedProperty);
+            var requestedString = JsonUtility.ReadProperty<string>(jObject, RequestedProperty);
 
             if (!string.IsNullOrEmpty(requestedString))
             {
                 dependency.RequestedVersion = VersionRange.Parse(requestedString);
             }
 
-            dependency.Sha512 = LockFileFormat.ReadProperty<string>(jObject, Sha512Property);
+            dependency.Sha512 = JsonUtility.ReadProperty<string>(jObject, Sha512Property);
 
             return dependency;
         }
 
         private static JProperty WriteTarget(PackagesLockFileTarget target)
         {
-            var json = LockFileFormat.WriteObject(target.Dependencies, WriteTargetDependency);
+            var json = JsonUtility.WriteObject(target.Dependencies, WriteTargetDependency);
 
             var key = target.Name;
 
@@ -236,7 +236,7 @@ private static JProperty WriteTargetDependency(LockFileDependency dependency)
             {
                 var ordered = dependency.Dependencies.OrderBy(dep => dep.Id, StringComparer.Ordinal);
 
-                json[DependenciesProperty] = LockFileFormat.WriteObject(ordered, LockFileFormat.WritePackageDependency);
+                json[DependenciesProperty] = JsonUtility.WriteObject(ordered, JsonUtility.WritePackageDependency);
             }
 
             return new JProperty(dependency.Id, json);
diff --git a/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackagesLockFileUtilities.cs b/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackagesLockFileUtilities.cs
index bd06b55e39c..1e1ded0ecf1 100644
--- a/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackagesLockFileUtilities.cs
+++ b/src/NuGet.Core/NuGet.ProjectModel/ProjectLockFile/PackagesLockFileUtilities.cs
@@ -55,7 +55,7 @@ public static bool IsLockFileStillValid(DependencyGraphSpec dgSpec, PackagesLock
 
                 if (target != null)
                 {
-                    var directDependencies = target.Dependencies.Where(dep => dep.Type == PackageInstallationType.Direct);
+                    var directDependencies = target.Dependencies.Where(dep => dep.Type == PackageDependencyType.Direct);
 
                     if (HasProjectDependencyChanged(framework.Dependencies, directDependencies))
                     {
@@ -73,6 +73,8 @@ public static bool IsLockFileStillValid(DependencyGraphSpec dgSpec, PackagesLock
                     continue;
                 }
 
+                var projectName = Path.GetFileNameWithoutExtension(p2p.RestoreMetadata.ProjectPath);
+
                 foreach (var framework in p2p.TargetFrameworks)
                 {
                     var target = nuGetLockFile.Targets.FirstOrDefault(
@@ -81,8 +83,8 @@ public static bool IsLockFileStillValid(DependencyGraphSpec dgSpec, PackagesLock
                     if (target != null)
                     {
                         var projectDependency = target.Dependencies.FirstOrDefault(
-                            dep => dep.Type == PackageInstallationType.Project &&
-                            PathUtility.GetStringComparerBasedOnOS().Equals(dep.Id, p2p.RestoreMetadata.ProjectName));
+                            dep => dep.Type == PackageDependencyType.Project &&
+                            PathUtility.GetStringComparerBasedOnOS().Equals(dep.Id, projectName));
 
                         if (HasP2PDependencyChanged(framework.Dependencies, projectDependency))
                         {
@@ -100,7 +102,7 @@ private static bool HasProjectDependencyChanged(IEnumerable<LibraryDependency> n
         {
             foreach (var dependency in newDependencies.Where(dep => dep.LibraryRange.TypeConstraint == LibraryDependencyTarget.Package))
             {
-                var lockFileDependency = lockFileDependencies.FirstOrDefault(d => PathUtility.GetStringComparerBasedOnOS().Equals(d.Id, dependency.Name));
+                var lockFileDependency = lockFileDependencies.FirstOrDefault(d => StringComparer.OrdinalIgnoreCase.Equals(d.Id, dependency.Name));
 
                 if (lockFileDependency == null || !EqualityUtility.EqualsWithNullCheck(lockFileDependency.RequestedVersion, dependency.LibraryRange.VersionRange))
                 {
@@ -123,7 +125,7 @@ private static bool HasP2PDependencyChanged(IEnumerable<LibraryDependency> newDe
 
             foreach (var dependency in newDependencies.Where(dep => dep.LibraryRange.TypeConstraint == LibraryDependencyTarget.Package))
             {
-                var matchedP2PLibrary = projectDependency.Dependencies.FirstOrDefault(dep => PathUtility.GetStringComparerBasedOnOS().Equals(dep.Id, dependency.Name));
+                var matchedP2PLibrary = projectDependency.Dependencies.FirstOrDefault(dep => StringComparer.OrdinalIgnoreCase.Equals(dep.Id, dependency.Name));
 
                 if (matchedP2PLibrary == null || !EqualityUtility.EqualsWithNullCheck(matchedP2PLibrary.VersionRange, dependency.LibraryRange.VersionRange))
                 {
diff --git a/test/NuGet.Clients.FuncTests/NuGet.CommandLine.FuncTest/Commands/RestoreCommandTests.cs b/test/NuGet.Clients.FuncTests/NuGet.CommandLine.FuncTest/Commands/RestoreCommandTests.cs
index 513206c0875..5241008812c 100644
--- a/test/NuGet.Clients.FuncTests/NuGet.CommandLine.FuncTest/Commands/RestoreCommandTests.cs
+++ b/test/NuGet.Clients.FuncTests/NuGet.CommandLine.FuncTest/Commands/RestoreCommandTests.cs
@@ -138,11 +138,11 @@ public async Task Restore_LegacyPackageReference_WithNuGetLockFilePath()
                 Assert.Equal(".NETFramework,Version=v4.6.1", targets[0].Name);
                 Assert.Equal(3, targets[0].Dependencies.Count);
                 Assert.Equal("x", targets[0].Dependencies[0].Id);
-                Assert.Equal(PackageInstallationType.Direct, targets[0].Dependencies[0].Type);
+                Assert.Equal(PackageDependencyType.Direct, targets[0].Dependencies[0].Type);
                 Assert.Equal("y", targets[0].Dependencies[1].Id);
-                Assert.Equal(PackageInstallationType.Transitive, targets[0].Dependencies[1].Type);
+                Assert.Equal(PackageDependencyType.Transitive, targets[0].Dependencies[1].Type);
                 Assert.Equal("b", targets[0].Dependencies[2].Id);
-                Assert.Equal(PackageInstallationType.Project, targets[0].Dependencies[2].Type);
+                Assert.Equal(PackageDependencyType.Project, targets[0].Dependencies[2].Type);
             }
         }
 
diff --git a/test/NuGet.Clients.Tests/NuGet.PackageManagement.VisualStudio.Test/ProjectSystems/LegacyPackageReferenceRestoreUtilityTests.cs b/test/NuGet.Clients.Tests/NuGet.PackageManagement.VisualStudio.Test/ProjectSystems/LegacyPackageReferenceRestoreUtilityTests.cs
index 33be9b06c42..00aa5586160 100644
--- a/test/NuGet.Clients.Tests/NuGet.PackageManagement.VisualStudio.Test/ProjectSystems/LegacyPackageReferenceRestoreUtilityTests.cs
+++ b/test/NuGet.Clients.Tests/NuGet.PackageManagement.VisualStudio.Test/ProjectSystems/LegacyPackageReferenceRestoreUtilityTests.cs
@@ -103,13 +103,14 @@ public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_Success
                     // Act
                     var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                         testSolutionManager,
+                        dgSpec,
                         restoreContext,
                         providersCache,
                         (c) => { },
                         sourceRepositoryProvider.GetRepositories(),
                         Guid.Empty,
                         false,
-                        dgSpec,
+                        true,
                         testLogger,
                         CancellationToken.None);
 
@@ -232,13 +233,14 @@ public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_Generat
                     // Act
                     var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                         testSolutionManager,
+                        dgSpec,
                         restoreContext,
                         providersCache,
                         (c) => { },
                         sourceRepositoryProvider.GetRepositories(),
                         Guid.Empty,
                         false,
-                        dgSpec,
+                        true,
                         testLogger,
                         CancellationToken.None);
 
@@ -256,11 +258,11 @@ public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_Generat
                     Assert.Equal(".NETFramework,Version=v4.5", lockFile.Targets[0].Name);
                     Assert.Equal(3, lockFile.Targets[0].Dependencies.Count);
                     Assert.Equal("packageA", lockFile.Targets[0].Dependencies[0].Id);
-                    Assert.Equal(PackageInstallationType.Direct, lockFile.Targets[0].Dependencies[0].Type);
+                    Assert.Equal(PackageDependencyType.Direct, lockFile.Targets[0].Dependencies[0].Type);
                     Assert.Equal("packageB", lockFile.Targets[0].Dependencies[1].Id);
-                    Assert.Equal(PackageInstallationType.Transitive, lockFile.Targets[0].Dependencies[1].Type);
+                    Assert.Equal(PackageDependencyType.Transitive, lockFile.Targets[0].Dependencies[1].Type);
                     Assert.Equal("project2", lockFile.Targets[0].Dependencies[2].Id);
-                    Assert.Equal(PackageInstallationType.Project, lockFile.Targets[0].Dependencies[2].Type);
+                    Assert.Equal(PackageDependencyType.Project, lockFile.Targets[0].Dependencies[2].Type);
                 }
             }
         }
@@ -333,13 +335,14 @@ public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_ReadLoc
 
                     var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                         testSolutionManager,
+                        dgSpec,
                         restoreContext,
                         new RestoreCommandProvidersCache(),
                         (c) => { },
                         sourceRepositoryProvider.GetRepositories(),
                         Guid.Empty,
                         false,
-                        dgSpec,
+                        true,
                         testLogger,
                         CancellationToken.None);
 
@@ -363,13 +366,14 @@ public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_ReadLoc
                     // Act
                     restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                         testSolutionManager,
+                        dgSpec,
                         restoreContext,
                         new RestoreCommandProvidersCache(),
                         (c) => { },
                         sourceRepositoryProvider.GetRepositories(),
                         Guid.Empty,
                         false,
-                        dgSpec,
+                        true,
                         testLogger,
                         CancellationToken.None);
 
@@ -463,13 +467,14 @@ public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_UpdateL
 
                     var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                         testSolutionManager,
+                        dgSpec,
                         restoreContext,
                         new RestoreCommandProvidersCache(),
                         (c) => { },
                         sourceRepositoryProvider.GetRepositories(),
                         Guid.Empty,
                         false,
-                        dgSpec,
+                        true,
                         testLogger,
                         CancellationToken.None);
 
@@ -510,13 +515,14 @@ public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_UpdateL
                     // Act
                     restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                         testSolutionManager,
+                        dgSpec,
                         restoreContext,
                         new RestoreCommandProvidersCache(),
                         (c) => { },
                         sourceRepositoryProvider.GetRepositories(),
                         Guid.Empty,
                         false,
-                        dgSpec,
+                        true,
                         testLogger,
                         CancellationToken.None);
 
@@ -606,13 +612,14 @@ public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_Restore
                     // Act
                     var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                         testSolutionManager,
+                        dgSpec,
                         restoreContext,
                         providersCache,
                         (c) => { },
                         sourceRepositoryProvider.GetRepositories(),
                         Guid.Empty,
                         false,
-                        dgSpec,
+                        true,
                         testLogger,
                         CancellationToken.None);
 
@@ -696,13 +703,14 @@ public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_LockedM
 
                     var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                         testSolutionManager,
+                        dgSpec,
                         restoreContext,
                         new RestoreCommandProvidersCache(),
                         (c) => { },
                         sourceRepositoryProvider.GetRepositories(),
                         Guid.Empty,
                         false,
-                        dgSpec,
+                        true,
                         testLogger,
                         CancellationToken.None);
 
@@ -739,13 +747,14 @@ public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_LockedM
                     // Act
                     restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                         testSolutionManager,
+                        dgSpec,
                         restoreContext,
                         new RestoreCommandProvidersCache(),
                         (c) => { },
                         sourceRepositoryProvider.GetRepositories(),
                         Guid.Empty,
                         false,
-                        dgSpec,
+                        true,
                         testLogger,
                         CancellationToken.None);
 
@@ -828,13 +837,14 @@ public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_Package
 
                     var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                         testSolutionManager,
+                        dgSpec,
                         restoreContext,
                         new RestoreCommandProvidersCache(),
                         (c) => { },
                         sourceRepositoryProvider.GetRepositories(),
                         Guid.Empty,
                         false,
-                        dgSpec,
+                        true,
                         testLogger,
                         CancellationToken.None);
 
@@ -863,13 +873,14 @@ public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_Package
                     // Act
                     restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                         testSolutionManager,
+                        dgSpec,
                         restoreContext,
                         new RestoreCommandProvidersCache(),
                         (c) => { },
                         sourceRepositoryProvider.GetRepositories(),
                         Guid.Empty,
                         false,
-                        dgSpec,
+                        true,
                         testLogger,
                         CancellationToken.None);
 
@@ -953,13 +964,14 @@ public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_Reevalu
 
                     var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                         testSolutionManager,
+                        dgSpec,
                         restoreContext,
                         new RestoreCommandProvidersCache(),
                         (c) => { },
                         sourceRepositoryProvider.GetRepositories(),
                         Guid.Empty,
                         false,
-                        dgSpec,
+                        true,
                         testLogger,
                         CancellationToken.None);
 
@@ -983,13 +995,14 @@ public async void DependencyGraphRestoreUtility_LegacyPackageRef_Restore_Reevalu
                     // Act
                     restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                         testSolutionManager,
+                        dgSpec,
                         restoreContext,
                         new RestoreCommandProvidersCache(),
                         (c) => { },
                         sourceRepositoryProvider.GetRepositories(),
                         Guid.Empty,
                         false,
-                        dgSpec,
+                        true,
                         testLogger,
                         CancellationToken.None);
 
diff --git a/test/NuGet.Core.Tests/NuGet.PackageManagement.Test/BuildIntegratedTests.cs b/test/NuGet.Core.Tests/NuGet.PackageManagement.Test/BuildIntegratedTests.cs
index 36aaab71f0e..60034a7215e 100644
--- a/test/NuGet.Core.Tests/NuGet.PackageManagement.Test/BuildIntegratedTests.cs
+++ b/test/NuGet.Core.Tests/NuGet.PackageManagement.Test/BuildIntegratedTests.cs
@@ -1814,13 +1814,14 @@ public async void TestPacMan_BuildIntegrated_PreviewUpdatesAsync_WithStrictVersi
 
                 await DependencyGraphRestoreUtility.RestoreAsync(
                     testSolutionManager,
+                    dgSpec1,
                     restoreContext,
                     providersCache,
                     (c) => { },
                     sourceRepositoryProvider.GetRepositories(),
                     Guid.Empty,
                     false,
-                    dgSpec1,
+                    true,
                     testLogger,
                     CancellationToken.None);
 
diff --git a/test/NuGet.Core.Tests/NuGet.PackageManagement.Test/BuildIntegration/BuildIntegratedNuGetProjectTests.cs b/test/NuGet.Core.Tests/NuGet.PackageManagement.Test/BuildIntegration/BuildIntegratedNuGetProjectTests.cs
index c839fa676db..34459ea98ee 100644
--- a/test/NuGet.Core.Tests/NuGet.PackageManagement.Test/BuildIntegration/BuildIntegratedNuGetProjectTests.cs
+++ b/test/NuGet.Core.Tests/NuGet.PackageManagement.Test/BuildIntegration/BuildIntegratedNuGetProjectTests.cs
@@ -62,26 +62,28 @@ public async Task BuildIntegratedNuGetProject_IsRestoreRequiredChangedSha512()
 
                 await DependencyGraphRestoreUtility.RestoreAsync(
                     solutionManager,
+                    dgSpec1,
                     restoreContext,
                     providersCache,
                     (c) => { },
                     sources,
                     Guid.Empty,
                     false,
-                    dgSpec1,
+                    true,
                     testLogger,
                     CancellationToken.None);
 
                 var dgSpec2 = await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext);
                 var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                     solutionManager,
+                    dgSpec2,
                     restoreContext,
                     providersCache,
                     (c) => { },
                     sources,
                     Guid.Empty,
                     false,
-                    dgSpec2,
+                    true,
                     testLogger,
                     CancellationToken.None);
 
@@ -97,13 +99,14 @@ public async Task BuildIntegratedNuGetProject_IsRestoreRequiredChangedSha512()
 
                 var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                     solutionManager,
+                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
                     restoreContext,
                     new RestoreCommandProvidersCache(),
                     (c) => { },
                     sources,
                     Guid.Empty,
                     false,
-                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
+                    true,
                     testLogger,
                     CancellationToken.None);
 
@@ -166,13 +169,14 @@ public async Task BuildIntegratedNuGetProject_RestoreFailed_PersistDGSpecFile()
 
                 var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                     solutionManager,
+                    dgSpec,
                     restoreContext,
                     providersCache,
                     (c) => { },
                     sources,
                     Guid.Empty,
                     false,
-                    dgSpec,
+                    true,
                     testLogger,
                     CancellationToken.None);
 
@@ -228,25 +232,27 @@ public async Task BuildIntegratedNuGetProject_IsRestoreRequiredMissingPackage()
 
                 await DependencyGraphRestoreUtility.RestoreAsync(
                     solutionManager,
+                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
                     restoreContext,
                     providersCache,
                     (c) => { },
                     sources,
                     Guid.Empty,
                     false,
-                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
+                    true,
                     testLogger,
                     CancellationToken.None);
 
                 var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                     solutionManager,
+                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
                     restoreContext,
                     providersCache,
                     (c) => { },
                     sources,
                     Guid.Empty,
                     false,
-                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
+                    true,
                     testLogger,
                     CancellationToken.None);
 
@@ -262,13 +268,14 @@ public async Task BuildIntegratedNuGetProject_IsRestoreRequiredMissingPackage()
 
                 var restoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                     solutionManager,
+                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
                     restoreContext,
                     new RestoreCommandProvidersCache(),
                     (c) => { },
                     sources,
                     Guid.Empty,
                     false,
-                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
+                    true,
                     testLogger,
                     CancellationToken.None);
 
@@ -325,25 +332,27 @@ public async Task BuildIntegratedNuGetProject_IsRestoreNotRequiredWithFloatingVe
 
                 await DependencyGraphRestoreUtility.RestoreAsync(
                     solutionManager,
+                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
                     restoreContext,
                     providersCache,
                     (c) => { },
                     sources,
                     Guid.Empty,
                     false,
-                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
+                    true,
                     testLogger,
                     CancellationToken.None);
 
                 var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                     solutionManager,
+                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
                     restoreContext,
                     providersCache,
                     (c) => { },
                     sources,
                     Guid.Empty,
                     false,
-                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
+                    true,
                     testLogger,
                     CancellationToken.None);
 
@@ -401,25 +410,27 @@ public async Task BuildIntegratedNuGetProject_IsRestoreRequiredWithNoChanges()
 
                 await DependencyGraphRestoreUtility.RestoreAsync(
                     solutionManager,
+                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
                     restoreContext,
                     providersCache,
                     (c) => { },
                     sources,
                     Guid.Empty,
                     false,
-                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
+                    true,
                     testLogger,
                     CancellationToken.None);
 
                 var noOpRestoreSummaries = await DependencyGraphRestoreUtility.RestoreAsync(
                     solutionManager,
+                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
                     restoreContext,
                     providersCache,
                     (c) => { },
                     sources,
                     Guid.Empty,
                     false,
-                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
+                    true,
                     testLogger,
                     CancellationToken.None);
 
@@ -475,13 +486,14 @@ public async Task BuildIntegratedNuGetProject_IsRestoreRequiredWithNoChangesFall
 
                 await DependencyGraphRestoreUtility.RestoreAsync(
                     solutionManager,
+                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
                     restoreContext,
                     new RestoreCommandProvidersCache(),
                     (c) => { },
                     sources,
                     Guid.Empty,
                     false,
-                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
+                    true,
                     testLogger,
                     CancellationToken.None);
 
diff --git a/test/NuGet.Core.Tests/NuGet.PackageManagement.Test/BuildIntegration/BuildIntegratedRestoreUtilityTests.cs b/test/NuGet.Core.Tests/NuGet.PackageManagement.Test/BuildIntegration/BuildIntegratedRestoreUtilityTests.cs
index 7e915836a51..2bbba60c193 100644
--- a/test/NuGet.Core.Tests/NuGet.PackageManagement.Test/BuildIntegration/BuildIntegratedRestoreUtilityTests.cs
+++ b/test/NuGet.Core.Tests/NuGet.PackageManagement.Test/BuildIntegration/BuildIntegratedRestoreUtilityTests.cs
@@ -58,13 +58,14 @@ public async Task BuildIntegratedRestoreUtility_RestoreProjectNameProjectJson()
                 // Act
                 await DependencyGraphRestoreUtility.RestoreAsync(
                     solutionManager,
+                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
                     restoreContext,
                     new RestoreCommandProvidersCache(),
                     (c) => { },
                     sources,
                     Guid.Empty,
                     false,
-                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
+                    true,
                     testLogger,
                     CancellationToken.None);
 
@@ -110,13 +111,14 @@ public async Task BuildIntegratedRestoreUtility_BasicRestoreTest()
                 // Act
                 await DependencyGraphRestoreUtility.RestoreAsync(
                     solutionManager,
+                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
                     restoreContext,
                     new RestoreCommandProvidersCache(),
                     (c) => { },
                     sources,
                     Guid.Empty,
                     false,
-                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
+                    true,
                     testLogger,
                     CancellationToken.None);
 
@@ -178,13 +180,14 @@ public async Task BuildIntegratedRestoreUtility_RestoreToRelativePathGlobalPacka
                 // Act
                 await DependencyGraphRestoreUtility.RestoreAsync(
                     solutionManager,
+                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
                     restoreContext,
                     new RestoreCommandProvidersCache(),
                     (c) => { },
                     sources,
                     Guid.Empty,
                     false,
-                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
+                    true,
                     testLogger,
                     CancellationToken.None);
 
diff --git a/test/NuGet.Core.Tests/NuGet.PackageManagement.Test/BuildIntegration/DependencyGraphRestoreUtilityTests.cs b/test/NuGet.Core.Tests/NuGet.PackageManagement.Test/BuildIntegration/DependencyGraphRestoreUtilityTests.cs
index ce700c63ae8..a3e2268d8fb 100644
--- a/test/NuGet.Core.Tests/NuGet.PackageManagement.Test/BuildIntegration/DependencyGraphRestoreUtilityTests.cs
+++ b/test/NuGet.Core.Tests/NuGet.PackageManagement.Test/BuildIntegration/DependencyGraphRestoreUtilityTests.cs
@@ -55,13 +55,14 @@ public async Task DependencyGraphRestoreUtility_NoopRestoreTest()
                 // Act
                 await DependencyGraphRestoreUtility.RestoreAsync(
                     solutionManager,
+                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
                     restoreContext,
                     new RestoreCommandProvidersCache(),
                     (c) => { },
                     sources,
                     Guid.Empty,
                     false,
-                    await DependencyGraphRestoreUtility.GetSolutionRestoreSpec(solutionManager, restoreContext),
+                    true,
                     logger,
                     CancellationToken.None);
 
diff --git a/test/NuGet.Core.Tests/NuGet.ProjectModel.Test/PackagesLockFileFormatTests.cs b/test/NuGet.Core.Tests/NuGet.ProjectModel.Test/PackagesLockFileFormatTests.cs
index 1aa9873c4f1..fa570ca385e 100644
--- a/test/NuGet.Core.Tests/NuGet.ProjectModel.Test/PackagesLockFileFormatTests.cs
+++ b/test/NuGet.Core.Tests/NuGet.ProjectModel.Test/PackagesLockFileFormatTests.cs
@@ -43,7 +43,7 @@ public void PackagesLockFileFormat_Read()
             Assert.Equal(2, target.Dependencies.Count);
 
             Assert.Equal("PackageA", target.Dependencies[0].Id);
-            Assert.Equal(PackageInstallationType.Direct, target.Dependencies[0].Type);
+            Assert.Equal(PackageDependencyType.Direct, target.Dependencies[0].Type);
             Assert.Equal("[1.*, )", target.Dependencies[0].RequestedVersion.ToNormalizedString());
             Assert.Equal("1.0.0", target.Dependencies[0].ResolvedVersion.ToNormalizedString());
             Assert.NotEmpty(target.Dependencies[0].Sha512);
@@ -52,7 +52,7 @@ public void PackagesLockFileFormat_Read()
 
 
             Assert.Equal("PackageB", target.Dependencies[1].Id);
-            Assert.Equal(PackageInstallationType.Transitive, target.Dependencies[1].Type);
+            Assert.Equal(PackageDependencyType.Transitive, target.Dependencies[1].Type);
             Assert.Null(target.Dependencies[1].RequestedVersion);
             Assert.Equal("1.0.0", target.Dependencies[0].ResolvedVersion.ToNormalizedString());
             Assert.NotEmpty(target.Dependencies[1].Sha512);
@@ -109,7 +109,7 @@ public void PackagesLockFileFormat_ReadWithRuntimeGraph()
             Assert.Equal(2, target.Dependencies.Count);
 
             Assert.Equal("PackageA", target.Dependencies[0].Id);
-            Assert.Equal(PackageInstallationType.Direct, target.Dependencies[0].Type);
+            Assert.Equal(PackageDependencyType.Direct, target.Dependencies[0].Type);
             Assert.Equal("[1.*, )", target.Dependencies[0].RequestedVersion.ToNormalizedString());
             Assert.Equal("1.0.0", target.Dependencies[0].ResolvedVersion.ToNormalizedString());
             Assert.NotEmpty(target.Dependencies[0].Sha512);
@@ -120,7 +120,7 @@ public void PackagesLockFileFormat_ReadWithRuntimeGraph()
             // Runtime graph will only have additional transitive dependenies which are not part of
             // original TFM graph
             Assert.Equal("runtime.win10-arm.PackageA", target.Dependencies[1].Id);
-            Assert.Equal(PackageInstallationType.Transitive, target.Dependencies[1].Type);
+            Assert.Equal(PackageDependencyType.Transitive, target.Dependencies[1].Type);
             Assert.Null(target.Dependencies[1].RequestedVersion);
             Assert.Equal("1.0.0", target.Dependencies[0].ResolvedVersion.ToNormalizedString());
             Assert.NotEmpty(target.Dependencies[1].Sha512);
diff --git a/test/NuGet.Core.Tests/NuGet.ProjectModel.Test/PackagesLockFileTests.cs b/test/NuGet.Core.Tests/NuGet.ProjectModel.Test/PackagesLockFileTests.cs
index 3dda8354378..0c24c9a1b1c 100644
--- a/test/NuGet.Core.Tests/NuGet.ProjectModel.Test/PackagesLockFileTests.cs
+++ b/test/NuGet.Core.Tests/NuGet.ProjectModel.Test/PackagesLockFileTests.cs
@@ -32,7 +32,7 @@ public void PackagesLockFile_Equals()
                                 new LockFileDependency()
                                 {
                                     Id = "PackageA",
-                                    Type = PackageInstallationType.Direct,
+                                    Type = PackageDependencyType.Direct,
                                     RequestedVersion = VersionRange.Parse("1.0.0"),
                                     ResolvedVersion = NuGetVersion.Parse("1.0.0"),
                                     Sha512 = "sha1",
@@ -44,7 +44,7 @@ public void PackagesLockFile_Equals()
                                 new LockFileDependency()
                                 {
                                     Id = "PackageB",
-                                    Type = PackageInstallationType.Transitive,
+                                    Type = PackageDependencyType.Transitive,
                                     ResolvedVersion = NuGetVersion.Parse("1.0.0"),
                                     Sha512 = "sha2"
                                 }
@@ -61,7 +61,7 @@ public void PackagesLockFile_Equals()
                                 new LockFileDependency()
                                 {
                                     Id = "PackageA",
-                                    Type = PackageInstallationType.Direct,
+                                    Type = PackageDependencyType.Direct,
                                     RequestedVersion = VersionRange.Parse("1.0.0"),
                                     ResolvedVersion = NuGetVersion.Parse("1.0.0"),
                                     Sha512 = "sha3",
@@ -73,7 +73,7 @@ public void PackagesLockFile_Equals()
                                 new LockFileDependency()
                                 {
                                     Id = "runtime.win10-arm.PackageA",
-                                    Type = PackageInstallationType.Transitive,
+                                    Type = PackageDependencyType.Transitive,
                                     ResolvedVersion = NuGetVersion.Parse("1.0.0"),
                                     Sha512 = "sha4"
                                 }
diff --git a/test/NuGet.Core.Tests/NuGet.ProjectModel.Test/ProjectRestoreMetadataTests.cs b/test/NuGet.Core.Tests/NuGet.ProjectModel.Test/ProjectRestoreMetadataTests.cs
index cba58a5f886..63a8a138a09 100644
--- a/test/NuGet.Core.Tests/NuGet.ProjectModel.Test/ProjectRestoreMetadataTests.cs
+++ b/test/NuGet.Core.Tests/NuGet.ProjectModel.Test/ProjectRestoreMetadataTests.cs
@@ -116,6 +116,7 @@ private ProjectRestoreMetadata CreateProjectRestoreMetadata()
             var noWarn = new HashSet<NuGetLogCode>() { NuGetLogCode.NU1000, NuGetLogCode.NU1500 };
             var warningsAsErrors = new HashSet<NuGetLogCode>() { NuGetLogCode.NU1001, NuGetLogCode.NU1501 };
             var warningProperties = new WarningProperties(allWarningsAsErrors: allWarningsAsErrors, warningsAsErrors: warningsAsErrors, noWarn: noWarn);
+            var restoreLockProperties = new RestoreLockProperties(restorePackagesWithLockFile: "true", nuGetLockFilePath: null, restoreLockedMode: false, reevaluateNuGetLockFile: false);
             var originalProjectRestoreMetadata = new ProjectRestoreMetadata
             {
                 ProjectStyle = ProjectStyle.PackageReference,
@@ -136,7 +137,8 @@ private ProjectRestoreMetadata CreateProjectRestoreMetadata()
                 ConfigFilePaths = new List<string>() { "config1" },
                 OriginalTargetFrameworks = new List<string>() { "net45" },
                 Files = new List<ProjectRestoreMetadataFile>() { new ProjectRestoreMetadataFile("packagePath", "absolutePath") },
-                ProjectWideWarningProperties = warningProperties
+                ProjectWideWarningProperties = warningProperties,
+                RestoreLockProperties = restoreLockProperties
             };
 
             return originalProjectRestoreMetadata;