Switch to code to generate deps file for tools using the lock file.

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

@@ -181,42 +181,37 @@ namespace Microsoft.DotNet.Cli.Utils
                 depsPathRoot,
                 toolLibrary.Name + FileNameSuffixes.DepsJson);
 
-            EnsureToolJsonDepsFileExists(toolLockFile, depsJsonPath);
+            EnsureToolJsonDepsFileExists(toolLockFile, depsJsonPath, toolLibrary);
 
             return depsJsonPath;
         }
 
         private void EnsureToolJsonDepsFileExists(
             LockFile toolLockFile,
-            string depsPath)
+            string depsPath,
+            LockFileTargetLibrary toolLibrary)
         {
             if (!File.Exists(depsPath))
             {
-                GenerateDepsJsonFile(toolLockFile, depsPath);
+                GenerateDepsJsonFile(toolLockFile, depsPath, toolLibrary);
             }
         }
 
         // Need to unit test this, so public
         public void GenerateDepsJsonFile(
             LockFile toolLockFile,
-            string depsPath)
+            string depsPath,
+            LockFileTargetLibrary toolLibrary)
         {
             Reporter.Verbose.WriteLine($"Generating deps.json at: {depsPath}");
 
-            var projectContext = new ProjectContextBuilder()
+            var singleProjectInfo = new SingleProjectInfo(
-                .WithLockFile(toolLockFile)
+                toolLibrary.Name,
-                .WithTargetFramework(s_toolPackageFramework.ToString())
+                toolLibrary.Version.ToFullString(),
-                .Build();
+                Enumerable.Empty<ResourceAssemblyInfo>());
-
-            var exporter = projectContext.CreateExporter(Constants.DefaultConfiguration);
 
             var dependencyContext = new DependencyContextBuilder()
-                .Build(null,
+                .Build(singleProjectInfo, null, toolLockFile, s_toolPackageFramework, null);
-                    null,
-                    exporter.GetAllExports(),
-                    true,
-                    s_toolPackageFramework,
-                    string.Empty);
 
             var tempDepsFile = Path.GetTempFileName();
             using (var fileStream = File.Open(tempDepsFile, FileMode.Open, FileAccess.Write))

src/Microsoft.DotNet.Cli.Utils/DependencyContextBuilding/DependencyContextBuilder.cs

@@ -0,0 +1,315 @@
+// 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.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using Microsoft.Extensions.DependencyModel;
+using NuGet.Frameworks;
+using NuGet.Packaging;
+using NuGet.Packaging.Core;
+using NuGet.ProjectModel;
+
+namespace Microsoft.DotNet.Cli.Utils
+{
+    internal class DependencyContextBuilder
+    {
+        private readonly VersionFolderPathResolver _versionFolderPathResolver;
+
+        public DependencyContextBuilder()
+        {
+            // This resolver is only used for building file names, so that base path is not required.
+            _versionFolderPathResolver = new VersionFolderPathResolver(path: null);
+        }
+
+        public DependencyContext Build(
+            SingleProjectInfo mainProjectInfo,
+            CompilationOptions compilationOptions,
+            LockFile lockFile,
+            NuGetFramework framework,
+            string runtime)
+        {
+            bool includeCompilationLibraries = compilationOptions != null;
+
+            LockFileTarget lockFileTarget = lockFile.GetTarget(framework, runtime);
+
+            IEnumerable<LockFileTargetLibrary> runtimeExports = lockFileTarget.GetRuntimeLibraries();
+            IEnumerable<LockFileTargetLibrary> compilationExports =
+                includeCompilationLibraries ?
+                    lockFileTarget.GetCompileLibraries() :
+                    Enumerable.Empty<LockFileTargetLibrary>();
+
+            var dependencyLookup = compilationExports
+                .Concat(runtimeExports)
+                .Distinct()
+                .Select(library => new Dependency(library.Name, library.Version.ToString()))
+                .ToDictionary(dependency => dependency.Name, StringComparer.OrdinalIgnoreCase);
+
+            var libraryLookup = lockFile.Libraries.ToDictionary(l => l.Name, StringComparer.OrdinalIgnoreCase);
+
+            var runtimeSignature = GenerateRuntimeSignature(runtimeExports);
+
+            IEnumerable<RuntimeLibrary> runtimeLibraries =
+                GetLibraries(runtimeExports, libraryLookup, dependencyLookup, runtime: true).Cast<RuntimeLibrary>();
+
+            IEnumerable<CompilationLibrary> compilationLibraries;
+            if (includeCompilationLibraries)
+            {
+                CompilationLibrary projectCompilationLibrary = GetProjectCompilationLibrary(
+                    mainProjectInfo,
+                    lockFile,
+                    lockFileTarget,
+                    dependencyLookup);
+                compilationLibraries = new[] { projectCompilationLibrary }
+                    .Concat(
+                        GetLibraries(compilationExports, libraryLookup, dependencyLookup, runtime: false)
+                        .Cast<CompilationLibrary>());
+            }
+            else
+            {
+                compilationLibraries = Enumerable.Empty<CompilationLibrary>();
+            }
+
+            return new DependencyContext(
+                new TargetInfo(framework.DotNetFrameworkName, runtime, runtimeSignature, lockFileTarget.IsPortable()),
+                compilationOptions ?? CompilationOptions.Default,
+                compilationLibraries,
+                runtimeLibraries,
+                new RuntimeFallbacks[] { });
+        }
+
+        private static string GenerateRuntimeSignature(IEnumerable<LockFileTargetLibrary> runtimeExports)
+        {
+            var sha1 = SHA1.Create();
+            var builder = new StringBuilder();
+            var packages = runtimeExports
+                .Where(libraryExport => libraryExport.Type == "package");
+            var separator = "|";
+            foreach (var libraryExport in packages)
+            {
+                builder.Append(libraryExport.Name);
+                builder.Append(separator);
+                builder.Append(libraryExport.Version.ToString());
+                builder.Append(separator);
+            }
+            var hash = sha1.ComputeHash(Encoding.UTF8.GetBytes(builder.ToString()));
+
+            builder.Clear();
+            foreach (var hashByte in hash)
+            {
+                builder.AppendFormat("{0:x2}", hashByte);
+            }
+            return builder.ToString();
+        }
+
+        private List<Dependency> GetProjectDependencies(
+            LockFile lockFile,
+            LockFileTarget lockFileTarget,
+            Dictionary<string, Dependency> dependencyLookup)
+        {
+
+            List<Dependency> dependencies = new List<Dependency>();
+
+            IEnumerable<ProjectFileDependencyGroup> projectFileDependencies = lockFile
+                .ProjectFileDependencyGroups
+                .Where(dg => dg.FrameworkName == string.Empty ||
+                             dg.FrameworkName == lockFileTarget.TargetFramework.DotNetFrameworkName);
+
+            foreach (string projectFileDependency in projectFileDependencies.SelectMany(dg => dg.Dependencies))
+            {
+                int separatorIndex = projectFileDependency.IndexOf(' ');
+                string dependencyName = separatorIndex > 0 ?
+                    projectFileDependency.Substring(0, separatorIndex) :
+                    projectFileDependency;
+
+                Dependency dependency;
+                if (dependencyLookup.TryGetValue(dependencyName, out dependency))
+                {
+                    dependencies.Add(dependency);
+                }
+            }
+
+            return dependencies;
+        }
+
+        private RuntimeLibrary GetProjectRuntimeLibrary(
+            SingleProjectInfo projectInfo,
+            LockFile lockFile,
+            LockFileTarget lockFileTarget,
+            Dictionary<string, Dependency> dependencyLookup)
+        {
+
+            RuntimeAssetGroup[] runtimeAssemblyGroups = new[] { new RuntimeAssetGroup(string.Empty, projectInfo.GetOutputName()) };
+
+            List<Dependency> dependencies = GetProjectDependencies(lockFile, lockFileTarget, dependencyLookup);
+
+            ResourceAssembly[] resourceAssemblies = projectInfo
+                .ResourceAssemblies
+                .Select(r => new ResourceAssembly(r.RelativePath, r.Culture))
+                .ToArray();
+
+            return new RuntimeLibrary(
+                type: "project",
+                name: projectInfo.Name,
+                version: projectInfo.Version,
+                hash: string.Empty,
+                runtimeAssemblyGroups: runtimeAssemblyGroups,
+                nativeLibraryGroups: new RuntimeAssetGroup[] { },
+                resourceAssemblies: resourceAssemblies,
+                dependencies: dependencies.ToArray(),
+                serviceable: false);
+        }
+
+        private CompilationLibrary GetProjectCompilationLibrary(
+            SingleProjectInfo projectInfo,
+            LockFile lockFile,
+            LockFileTarget lockFileTarget,
+            Dictionary<string, Dependency> dependencyLookup)
+        {
+            List<Dependency> dependencies = GetProjectDependencies(lockFile, lockFileTarget, dependencyLookup);
+
+            return new CompilationLibrary(
+                type: "project",
+                name: projectInfo.Name,
+                version: projectInfo.Version,
+                hash: string.Empty,
+                assemblies: new[] { projectInfo.GetOutputName() },
+                dependencies: dependencies.ToArray(),
+                serviceable: false);
+        }
+
+        private IEnumerable<Library> GetLibraries(
+            IEnumerable<LockFileTargetLibrary> exports,
+            IDictionary<string, LockFileLibrary> libraryLookup,
+            IDictionary<string, Dependency> dependencyLookup,
+            bool runtime)
+        {
+            return exports.Select(export => GetLibrary(export, libraryLookup, dependencyLookup, runtime));
+        }
+
+        private Library GetLibrary(
+            LockFileTargetLibrary export,
+            IDictionary<string, LockFileLibrary> libraryLookup,
+            IDictionary<string, Dependency> dependencyLookup,
+            bool runtime)
+        {
+            var type = export.Type;
+
+            // TEMPORARY: All packages are serviceable in RC2
+            // See https://github.com/dotnet/cli/issues/2569
+            var serviceable = export.Type == "package";
+            var libraryDependencies = new HashSet<Dependency>();
+
+            foreach (PackageDependency libraryDependency in export.Dependencies)
+            {
+                Dependency dependency;
+                if (dependencyLookup.TryGetValue(libraryDependency.Id, out dependency))
+                {
+                    libraryDependencies.Add(dependency);
+                }
+            }
+
+            string hash = string.Empty;
+            string path = null;
+            string hashPath = null;
+            LockFileLibrary library;
+            if (libraryLookup.TryGetValue(export.Name, out library))
+            {
+                if (!string.IsNullOrEmpty(library.Sha512))
+                {
+                    hash = "sha512-" + library.Sha512;
+                    hashPath = _versionFolderPathResolver.GetHashFileName(export.Name, export.Version);
+                }
+
+                path = library.Path;
+            }
+
+            if (runtime)
+            {
+                return new RuntimeLibrary(
+                    type.ToLowerInvariant(),
+                    export.Name,
+                    export.Version.ToString(),
+                    hash,
+                    CreateRuntimeAssemblyGroups(export),
+                    CreateNativeLibraryGroups(export),
+                    export.ResourceAssemblies.FilterPlaceHolderFiles().Select(CreateResourceAssembly),
+                    libraryDependencies,
+                    serviceable,
+                    path,
+                    hashPath);
+            }
+            else
+            {
+                IEnumerable<string> assemblies = export
+                    .CompileTimeAssemblies
+                    .FilterPlaceHolderFiles()
+                    .Select(libraryAsset => libraryAsset.Path);
+
+                return new CompilationLibrary(
+                    type.ToString().ToLowerInvariant(),
+                    export.Name,
+                    export.Version.ToString(),
+                    hash,
+                    assemblies,
+                    libraryDependencies,
+                    serviceable,
+                    path,
+                    hashPath);
+            }
+        }
+
+        private IReadOnlyList<RuntimeAssetGroup> CreateRuntimeAssemblyGroups(LockFileTargetLibrary export)
+        {
+            List<RuntimeAssetGroup> assemblyGroups = new List<RuntimeAssetGroup>();
+
+            assemblyGroups.Add(
+                new RuntimeAssetGroup(
+                    string.Empty,
+                    export.RuntimeAssemblies.FilterPlaceHolderFiles().Select(a => a.Path)));
+
+            foreach (var runtimeTargetsGroup in export.GetRuntimeTargetsGroups("runtime"))
+            {
+                assemblyGroups.Add(
+                    new RuntimeAssetGroup(
+                        runtimeTargetsGroup.Key,
+                        runtimeTargetsGroup.Select(t => t.Path)));
+            }
+
+            return assemblyGroups;
+        }
+
+        private IReadOnlyList<RuntimeAssetGroup> CreateNativeLibraryGroups(LockFileTargetLibrary export)
+        {
+            List<RuntimeAssetGroup> nativeGroups = new List<RuntimeAssetGroup>();
+
+            nativeGroups.Add(
+                new RuntimeAssetGroup(
+                    string.Empty,
+                    export.NativeLibraries.FilterPlaceHolderFiles().Select(a => a.Path)));
+
+            foreach (var runtimeTargetsGroup in export.GetRuntimeTargetsGroups("native"))
+            {
+                nativeGroups.Add(
+                    new RuntimeAssetGroup(
+                        runtimeTargetsGroup.Key,
+                        runtimeTargetsGroup.Select(t => t.Path)));
+            }
+
+            return nativeGroups;
+        }
+
+        private ResourceAssembly CreateResourceAssembly(LockFileItem resourceAssembly)
+        {
+            string locale;
+            if (!resourceAssembly.Properties.TryGetValue("locale", out locale))
+            {
+                locale = null;
+            }
+
+            return new ResourceAssembly(resourceAssembly.Path, locale);
+        }
+    }
+}

src/Microsoft.DotNet.Cli.Utils/DependencyContextBuilding/LockFileTargetExtensions.cs

@@ -0,0 +1,105 @@
+// 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.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NuGet.Packaging.Core;
+using NuGet.ProjectModel;
+
+namespace Microsoft.DotNet.Cli.Utils
+{
+    internal static class LockFileTargetExtensions
+    {
+        public static bool IsPortable(this LockFileTarget lockFileTarget)
+        {
+            return string.IsNullOrEmpty(lockFileTarget.RuntimeIdentifier) &&
+                lockFileTarget.GetPlatformLibrary() != null;
+        }
+
+        public static LockFileTargetLibrary GetPlatformLibrary(this LockFileTarget lockFileTarget)
+        {
+            // TODO: https://github.com/dotnet/sdk/issues/17 get this from the lock file
+            var platformPackageName = "Microsoft.NETCore.App";
+            var platformLibrary = lockFileTarget
+                .Libraries
+                .FirstOrDefault(e => e.Name.Equals(platformPackageName, StringComparison.OrdinalIgnoreCase));
+
+            return platformLibrary;
+        }
+
+        public static HashSet<string> GetPlatformExclusionList(
+            this LockFileTarget lockFileTarget,
+            IDictionary<string, LockFileTargetLibrary> libraryLookup)
+        {
+            var platformLibrary = lockFileTarget.GetPlatformLibrary();
+            var exclusionList = new HashSet<string>();
+
+            exclusionList.Add(platformLibrary.Name);
+            CollectDependencies(libraryLookup, platformLibrary.Dependencies, exclusionList);
+
+            return exclusionList;
+        }
+
+        public static IEnumerable<LockFileTargetLibrary> GetRuntimeLibraries(this LockFileTarget lockFileTarget)
+        {
+            IEnumerable<LockFileTargetLibrary> runtimeLibraries = lockFileTarget.Libraries;
+            Dictionary<string, LockFileTargetLibrary> libraryLookup =
+                runtimeLibraries.ToDictionary(e => e.Name, StringComparer.OrdinalIgnoreCase);
+
+            HashSet<string> allExclusionList = new HashSet<string>();
+
+            if (lockFileTarget.IsPortable())
+            {
+                allExclusionList.UnionWith(lockFileTarget.GetPlatformExclusionList(libraryLookup));
+            }
+
+            // TODO: exclude "type: build" dependencies during publish - https://github.com/dotnet/sdk/issues/42
+
+            return runtimeLibraries.Filter(allExclusionList).ToArray();
+        }
+
+        public static IEnumerable<LockFileTargetLibrary> GetCompileLibraries(this LockFileTarget lockFileTarget)
+        {
+            // TODO: exclude "type: build" dependencies during publish - https://github.com/dotnet/sdk/issues/42
+
+            return lockFileTarget.Libraries;
+        }
+
+        public static IEnumerable<LockFileTargetLibrary> Filter(
+            this IEnumerable<LockFileTargetLibrary> libraries,
+            HashSet<string> exclusionList)
+        {
+            return libraries.Where(e => !exclusionList.Contains(e.Name));
+        }
+
+        public static IEnumerable<IGrouping<string, LockFileRuntimeTarget>> GetRuntimeTargetsGroups(
+            this LockFileTargetLibrary library,
+            string assetType)
+        {
+            return library.RuntimeTargets
+                .FilterPlaceHolderFiles()
+                .Cast<LockFileRuntimeTarget>()
+                .Where(t => string.Equals(t.AssetType, assetType, StringComparison.OrdinalIgnoreCase))
+                .GroupBy(t => t.Runtime);
+        }
+
+        private static void CollectDependencies(
+            IDictionary<string, LockFileTargetLibrary> libraryLookup,
+            IEnumerable<PackageDependency> dependencies,
+            HashSet<string> exclusionList)
+        {
+            foreach (PackageDependency dependency in dependencies)
+            {
+                LockFileTargetLibrary library = libraryLookup[dependency.Id];
+                if (library.Version.Equals(dependency.VersionRange.MinVersion))
+                {
+                    if (exclusionList.Add(library.Name))
+                    {
+                        CollectDependencies(libraryLookup, library.Dependencies, exclusionList);
+                    }
+                }
+            }
+        }
+    }
+}

src/Microsoft.DotNet.Cli.Utils/DependencyContextBuilding/NuGetUtils.cs

@@ -0,0 +1,25 @@
+// 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.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using NuGet.Packaging.Core;
+using NuGet.ProjectModel;
+
+namespace Microsoft.DotNet.Cli.Utils
+{
+    internal static class NuGetUtils
+    {
+        public static bool IsPlaceholderFile(string path)
+        {
+            return string.Equals(Path.GetFileName(path), PackagingCoreConstants.EmptyFolder, StringComparison.Ordinal);
+        }
+
+        public static IEnumerable<LockFileItem> FilterPlaceHolderFiles(this IEnumerable<LockFileItem> files)
+        {
+            return files.Where(f => !IsPlaceholderFile(f.Path));
+        }
+    }
+}

src/Microsoft.DotNet.Cli.Utils/DependencyContextBuilding/ResourceAssemblyInfo.cs

@@ -0,0 +1,17 @@
+// 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.Cli.Utils
+{
+    internal class ResourceAssemblyInfo
+    {
+        public string Culture { get; }
+        public string RelativePath { get; }
+
+        public ResourceAssemblyInfo(string culture, string relativePath)
+        {
+            Culture = culture;
+            RelativePath = relativePath;
+        }
+    }
+}

src/Microsoft.DotNet.Cli.Utils/DependencyContextBuilding/SingleProjectInfo.cs

@@ -0,0 +1,27 @@
+// 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.
+
+using System.Collections.Generic;
+
+namespace Microsoft.DotNet.Cli.Utils
+{
+    internal class SingleProjectInfo
+    {
+        public string Name { get; }
+        public string Version { get; }
+
+        public IEnumerable<ResourceAssemblyInfo> ResourceAssemblies { get; }
+
+        public SingleProjectInfo(string name, string version, IEnumerable<ResourceAssemblyInfo> resourceAssemblies)
+        {
+            Name = name;
+            Version = version;
+            ResourceAssemblies = resourceAssemblies;
+        }
+
+        public string GetOutputName()
+        {
+            return $"{Name}.dll";
+        }
+    }
+}