Fix package code for new NuGet.

The new NuGet uses tolower paths, and we need to react to it.

Port dotnet#2722
Port dotnet#3554

TestAssets/LockFiles/ExportFiles/valid/project.lock.json

@@ -57,5 +57,9 @@
       "ClassLibrary2",
       "ClassLibrary3"
     ]
+  },
+  "packageFolders": {
+    "/foo/packages": {},
+    "/foo/packages2": {}
   }
 }

src/Microsoft.DotNet.Cli.Utils/CommandResolution/ToolPathCalculator.cs

@@ -55,7 +55,7 @@ public string GetLockFilePath(string packageId, NuGetVersion version, NuGetFrame
 
             return Path.Combine(
                 GetBaseToolPath(packageId),
-                version.ToNormalizedString(),
+                version.ToNormalizedString().ToLowerInvariant(),
                 framework.GetShortFolderName(),
                 "project.lock.json");
         }
@@ -65,7 +65,7 @@ private string GetBaseToolPath(string packageId)
             return Path.Combine(
                 _packagesDirectory,
                 ".tools",
-                packageId);
+                packageId.ToLowerInvariant());
         }
 
         private IEnumerable<NuGetVersion> GetAvailableToolVersions(string packageId)

src/Microsoft.DotNet.Compiler.Common/Executable.cs

@@ -67,7 +67,7 @@ private void VerifyCoreClrPresenceInPackageGraph()
                 .Any();
 
             // coreclr should be present for standalone apps
-            if (! isCoreClrPresent)
+            if (!isCoreClrPresent)
             {
                 throw new InvalidOperationException("Expected coreclr library not found in package graph. Please try running dotnet restore again.");
             }
@@ -94,7 +94,7 @@ private void MakeCompilationOutputRunnableForFullFramework()
         }
 
         private void MakeCompilationOutputRunnableForCoreCLR(bool skipRuntimeConfig)
-        {   
+        {
             WriteDepsFileAndCopyProjectDependencies(_exporter, skipRuntimeConfig);
 
             var isRunnable = _compilerOptions.EmitEntryPoint ?? _context.ProjectFile.OverrideIsRunnable;
@@ -276,8 +276,16 @@ private void WriteDevRuntimeConfig()
 
         private void AddAdditionalProbingPaths(JObject runtimeOptions)
         {
-            var additionalProbingPaths = new JArray(_context.PackagesDirectory);
-            runtimeOptions.Add("additionalProbingPaths", additionalProbingPaths);
+            if (_context.LockFile != null)
+            {
+                var additionalProbingPaths = new JArray();
+                foreach (var packageFolder in _context.LockFile.PackageFolders)
+                {
+                    additionalProbingPaths.Add(packageFolder.Path);
+                }
+
+                runtimeOptions.Add("additionalProbingPaths", additionalProbingPaths);
+            }
         }
 
         public void WriteDeps(IEnumerable<LibraryExport> runtimeExports, IEnumerable<LibraryExport> compilationExports)

src/Microsoft.DotNet.Configurer/NuGetCacheSentinel.cs

@@ -4,7 +4,7 @@
 using System.IO;
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.Extensions.EnvironmentAbstractions;
-using Microsoft.DotNet.ProjectModel.Resolution;
+using NuGet.Configuration;
 
 namespace Microsoft.DotNet.Configurer
 {
@@ -23,7 +23,7 @@ private string NuGetCachePath
             {
                 if (string.IsNullOrEmpty(_nugetCachePath))
                 {
-                    _nugetCachePath = PackageDependencyProvider.ResolvePackagesPath(null, null);
+                    _nugetCachePath = NuGetPathContext.Create(new NullSettings()).UserPackageFolder;
                 }
 
                 return _nugetCachePath;

src/Microsoft.DotNet.ProjectModel/Graph/LockFile.cs

@@ -20,6 +20,7 @@ public class LockFile
         public IList<LockFileProjectLibrary> ProjectLibraries { get; set; } = new List<LockFileProjectLibrary>();
         public IList<LockFileTarget> Targets { get; set; } = new List<LockFileTarget>();
         public ExportFile ExportFile { get; set; }
+        public IList<LockFilePackageFolder> PackageFolders { get; set; } = new List<LockFilePackageFolder>();
 
         public LockFile(string lockFilePath)
         {

src/Microsoft.DotNet.ProjectModel/Graph/LockFilePackageFolder.cs

@@ -0,0 +1,10 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+namespace Microsoft.DotNet.ProjectModel.Graph
+{
+    public class LockFilePackageFolder
+    {
+        public string Path { get; set; }
+    }
+}

src/Microsoft.DotNet.ProjectModel/Graph/LockFileReader.cs

@@ -117,6 +117,7 @@ private LockFile ReadLockFile(string lockFilePath, JObject cursor)
             lockFile.Targets = ReadObject(cursor.Value<JObject>("targets"), ReadTarget);
             lockFile.ProjectFileDependencyGroups = ReadObject(cursor.Value<JObject>("projectFileDependencyGroups"), ReadProjectFileDependencyGroup);
             ReadLibrary(cursor.Value<JObject>("libraries"), lockFile);
+            lockFile.PackageFolders = ReadObject(cursor.Value<JObject>("packageFolders"), ReadPackageFolder);
 
             return lockFile;
         }
@@ -194,6 +195,20 @@ private LockFileTarget ReadTarget(string property, JToken json)
             return target;
         }
 
+        private LockFilePackageFolder ReadPackageFolder(string property, JToken json)
+        {
+            var jobject = json as JObject;
+            if (jobject == null)
+            {
+                throw FileFormatException.Create("The value type is not an object.", json);
+            }
+
+            var packageFolder = new LockFilePackageFolder();
+            packageFolder.Path = property;
+
+            return packageFolder;
+        }
+
         private LockFileTargetLibrary ReadTargetLibrary(string property, JToken json)
         {
             var jobject = json as JObject;

src/Microsoft.DotNet.ProjectModel/ProjectContextBuilder.cs

@@ -3,14 +3,14 @@
 
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.IO;
 using System.Linq;
-using System.Reflection;
 using System.Text;
 using Microsoft.DotNet.InternalAbstractions;
 using Microsoft.DotNet.ProjectModel.Graph;
 using Microsoft.DotNet.ProjectModel.Resolution;
+using NuGet.Common;
+using NuGet.Configuration;
 using NuGet.Frameworks;
 
 namespace Microsoft.DotNet.ProjectModel
@@ -210,7 +210,6 @@ public ProjectContext Build()
             }
 
             RootDirectory = globalSettings?.DirectoryPath ?? RootDirectory;
-            PackagesDirectory = PackagesDirectory ?? PackageDependencyProvider.ResolvePackagesPath(RootDirectory, globalSettings);
 
             FrameworkReferenceResolver frameworkReferenceResolver;
             if (string.IsNullOrEmpty(ReferenceAssembliesPath))
@@ -228,6 +227,17 @@ public ProjectContext Build()
 
             ReadLockFile(diagnostics);
 
+            // some callers only give ProjectContextBuilder a LockFile
+            ProjectDirectory = ProjectDirectory ?? TryGetProjectDirectoryFromLockFile();
+
+            INuGetPathContext nugetPathContext = null;
+            if (ProjectDirectory != null)
+            {
+                nugetPathContext = NuGetPathContext.Create(ProjectDirectory);
+            }
+
+            PackagesDirectory = PackagesDirectory ?? nugetPathContext?.UserPackageFolder;
+
             var validLockFile = true;
             string lockFileValidationMessage = null;
 
@@ -271,7 +281,7 @@ public ProjectContext Build()
                 target = SelectTarget(LockFile, isPortable);
                 if (target != null)
                 {
-                    var nugetPackageResolver = new PackageDependencyProvider(PackagesDirectory, frameworkReferenceResolver);
+                    var nugetPackageResolver = new PackageDependencyProvider(nugetPathContext, frameworkReferenceResolver);
                     var msbuildProjectResolver = new MSBuildDependencyProvider(Project, ProjectResolver);
                     ScanLibraries(target, lockFileLookup, libraries, msbuildProjectResolver, nugetPackageResolver, projectResolver);
 
@@ -377,6 +387,18 @@ public ProjectContext Build()
                 diagnostics);
         }
 
+        private string TryGetProjectDirectoryFromLockFile()
+        {
+            string result = null;
+
+            if (LockFile != null && !string.IsNullOrEmpty(LockFile.LockFilePath))
+            {
+                result = Path.GetDirectoryName(LockFile.LockFilePath);
+            }
+
+            return result;
+        }
+
         private void ReadLockFile(ICollection<DiagnosticMessage> diagnostics)
         {
             try

src/Microsoft.DotNet.ProjectModel/Resolution/PackageDependencyProvider.cs

@@ -8,19 +8,24 @@
 using System.Reflection.Metadata;
 using System.Reflection.PortableExecutable;
 using Microsoft.DotNet.ProjectModel.Graph;
+using NuGet.Common;
 using NuGet.Frameworks;
 using NuGet.Packaging;
 
 namespace Microsoft.DotNet.ProjectModel.Resolution
 {
     public class PackageDependencyProvider
     {
-        private readonly VersionFolderPathResolver _packagePathResolver;
+        private readonly FallbackPackagePathResolver _packagePathResolver;
         private readonly FrameworkReferenceResolver _frameworkReferenceResolver;
 
-        public PackageDependencyProvider(string packagesPath, FrameworkReferenceResolver frameworkReferenceResolver)
+        public PackageDependencyProvider(INuGetPathContext nugetPathContext, FrameworkReferenceResolver frameworkReferenceResolver)
         {
-            _packagePathResolver = new VersionFolderPathResolver(packagesPath);
+            if (nugetPathContext != null)
+            {
+                _packagePathResolver = new FallbackPackagePathResolver(nugetPathContext);
+            }
+
             _frameworkReferenceResolver = frameworkReferenceResolver;
         }
 
@@ -40,8 +45,8 @@ public PackageDescription GetDescription(NuGetFramework targetFramework, LockFil
             var dependencies = new List<LibraryRange>(targetLibrary.Dependencies.Count + targetLibrary.FrameworkAssemblies.Count);
             PopulateDependencies(dependencies, targetLibrary, targetFramework);
 
-            var path = _packagePathResolver.GetInstallPath(package.Name, package.Version);
-            var exists = Directory.Exists(path);
+            var path = _packagePathResolver?.GetPackageDirectory(package.Name, package.Version);
+            bool exists = path != null;
 
             if (exists)
             {
@@ -155,35 +160,5 @@ public static bool IsPlaceholderFile(string path)
         {
             return string.Equals(Path.GetFileName(path), "_._", StringComparison.Ordinal);
         }
-
-        public static string ResolvePackagesPath(string rootDirectory, GlobalSettings settings)
-        {
-            // Order
-            // 1. global.json { "packages": "..." }
-            // 2. EnvironmentNames.PackagesStore environment variable
-            // 3. NuGet.config repositoryPath (maybe)?
-            // 4. {DefaultLocalRuntimeHomeDir}\packages
-
-            if (!string.IsNullOrEmpty(settings?.PackagesPath))
-            {
-                return Path.Combine(rootDirectory, settings.PackagesPath);
-            }
-
-            var runtimePackages = Environment.GetEnvironmentVariable(EnvironmentNames.PackagesStore);
-
-            if (!string.IsNullOrEmpty(runtimePackages))
-            {
-                return runtimePackages;
-            }
-
-            var profileDirectory = Environment.GetEnvironmentVariable("USERPROFILE");
-
-            if (string.IsNullOrEmpty(profileDirectory))
-            {
-                profileDirectory = Environment.GetEnvironmentVariable("HOME");
-            }
-
-            return Path.Combine(profileDirectory, ".nuget", "packages");
-        }
     }
 }

src/Microsoft.DotNet.ProjectModel/project.json

@@ -9,6 +9,7 @@
       "target": "project"
     },
     "Newtonsoft.Json": "9.0.1",
+    "NuGet.Configuration": "3.5.0-rc1-1653",
     "NuGet.Packaging": "3.5.0-rc1-1653",
     "NuGet.RuntimeModel": "3.5.0-rc1-1653",
     "System.Reflection.Metadata": "1.3.0"

src/Microsoft.Extensions.DependencyModel/Resolution/PackageCacheCompilationAssemblyResolver.cs

@@ -53,7 +53,8 @@ public bool TryResolveAssemblyPaths(CompilationLibrary library, List<string> ass
                 if (ResolverUtils.TryResolvePackagePath(_fileSystem, library, _packageCacheDirectory, out packagePath))
                 {
                     var hashAlgorithm = library.Hash.Substring(0, hashSplitterPos);
-                    var cacheHashPath = Path.Combine(packagePath, $"{library.Name}.{library.Version}.nupkg.{hashAlgorithm}");
+                    var cacheHashFileName = $"{library.Name.ToLowerInvariant()}.{library.Version.ToLowerInvariant()}.nupkg.{hashAlgorithm}";
+                    var cacheHashPath = Path.Combine(packagePath, cacheHashFileName);
 
                     if (_fileSystem.File.Exists(cacheHashPath) &&
                         _fileSystem.File.ReadAllText(cacheHashPath) == library.Hash.Substring(hashSplitterPos + 1))

src/Microsoft.Extensions.DependencyModel/Resolution/ResolverUtils.cs

@@ -12,7 +12,11 @@ internal static class ResolverUtils
     {
         internal static bool TryResolvePackagePath(IFileSystem fileSystem, CompilationLibrary library, string basePath, out string packagePath)
         {
-            packagePath = Path.Combine(basePath, library.Name, library.Version);
+            packagePath = Path.Combine(
+                basePath,
+                library.Name.ToLowerInvariant(),
+                library.Version.ToLowerInvariant());
+
             if (fileSystem.Directory.Exists(packagePath))
             {
                 return true;

src/dotnet-compile-fsc/Program.cs

@@ -13,6 +13,7 @@
 using Microsoft.DotNet.Cli.Utils;
 using Microsoft.DotNet.ProjectModel;
 using Microsoft.DotNet.ProjectModel.Resolution;
+using NuGet.Configuration;
 
 namespace Microsoft.DotNet.Tools.Compiler.Fsc
 {
@@ -296,7 +297,7 @@ private static Command RunFsc(List<string> fscArgs, string temp)
 
         private static FscCommandSpec ResolveFsc(List<string> fscArgs, string temp)
         {
-            var nugetPackagesRoot = PackageDependencyProvider.ResolvePackagesPath(null, null);
+            var nugetPackagesRoot = NuGetPathContext.Create(Directory.GetCurrentDirectory())?.UserPackageFolder;
             var depsFile = Path.Combine(AppContext.BaseDirectory, "dotnet-compile-fsc" + FileNameSuffixes.DepsJson);
 
             var depsJsonCommandResolver = new DepsJsonCommandResolver(nugetPackagesRoot);

src/dotnet/commands/dotnet-run/RunCommand.cs

@@ -145,13 +145,16 @@ private int RunExecutable()
             }
 
             List<string> hostArgs = new List<string>();
-            if (!_context.TargetFramework.IsDesktop())
+            if (!_context.TargetFramework.IsDesktop() && _context.LockFile != null)
             {
-                // Add Nuget Packages Probing Path
-                var nugetPackagesRoot = _context.PackagesDirectory;
-                var probingPathArg = "--additionalprobingpath";
-                hostArgs.Insert(0, nugetPackagesRoot);
-                hostArgs.Insert(0, probingPathArg);
+                // Add Nuget Packages Probing Paths
+                const string probingPathArg = "--additionalprobingpath";
+
+                foreach (var packageFolder in _context.LockFile.PackageFolders)
+                {
+                    hostArgs.Insert(0, packageFolder.Path);
+                    hostArgs.Insert(0, probingPathArg);
+                }
             }
 
             // Now launch the output and give it the results

test/Microsoft.DotNet.ProjectModel.Tests/LockFilePatchingTests.cs

@@ -120,6 +120,17 @@ public void TestMissmatchingFileVersionsUnderDesignTime()
             Assert.NotNull(LockFileReader.Read(lockFilePath, designTime: true));
         }
 
+        [Fact]
+        public void TestPackageFoldersLoadCorrectly()
+        {
+            var lockFilePath = GetLockFilePath("valid");
+            var lockFile = LockFileReader.Read(lockFilePath, designTime: false);
+
+            Assert.Equal(2, lockFile.PackageFolders.Count);
+            Assert.Equal("/foo/packages", lockFile.PackageFolders[0].Path);
+            Assert.Equal("/foo/packages2", lockFile.PackageFolders[1].Path);
+        }
+
         private static int LibraryNumberFromName(Microsoft.DotNet.ProjectModel.Graph.LockFileTargetLibrary library)
         {
             var libraryName = library.Name;