Add output PackageDependenciesBetweenPackages to ResolvePackageAssets

Author: ocalles

src/Tasks/Microsoft.NET.Build.Tasks/ResolvePackageAssets.cs

@@ -29,6 +29,8 @@ namespace Microsoft.NET.Build.Tasks
     /// </summary>
     public sealed class ResolvePackageAssets : TaskBase
     {
+        #region Input Items
+
         /// <summary>
         /// Path to assets.json.
         /// </summary>
@@ -162,6 +164,10 @@ public sealed class ResolvePackageAssets : TaskBase
         /// </summary>
         public bool DesignTimeBuild { get; set; }
 
+        #endregion
+
+        #region Output Items
+
         /// <summary>
         /// Full paths to assemblies from packages to pass to compiler as analyzers.
         /// </summary>
@@ -241,6 +247,13 @@ public sealed class ResolvePackageAssets : TaskBase
         [Output]
         public ITaskItem[] PackageDependencies { get; private set; }
 
+        /// <summary>
+        /// All the dependencies between packages. Each package has metadata 'ParentPackage'
+        /// to refer to the package that depends on it. For top level packages this value is blank.
+        /// </summary>
+        [Output]
+        public ITaskItem[] PackageDependenciesBetweenPackages { get; private set; }
+
         /// <summary>
         /// List of symbol files (.pdb) related to NuGet packages.
         /// </summary>
@@ -259,6 +272,8 @@ public sealed class ResolvePackageAssets : TaskBase
         [Output]
         public ITaskItem[] ReferenceDocumentationFiles { get; private set; }
 
+        #endregion
+
         /// <summary>
         /// Messages from the assets file.
         /// These are logged directly and therefore not returned to the targets (note private here).
@@ -345,6 +360,7 @@ private void ReadItemGroups()
                 NativeLibraries = reader.ReadItemGroup();
                 PackageDefinitions = reader.ReadItemGroup();
                 PackageDependencies = reader.ReadItemGroup();
+                PackageDependenciesBetweenPackages = reader.ReadItemGroup();
                 PackageFolders = reader.ReadItemGroup();
                 ReferenceDocumentationFiles = reader.ReadItemGroup();
                 ResourceAssemblies = reader.ReadItemGroup();
@@ -663,6 +679,8 @@ internal sealed class CacheWriter : IDisposable
         {
             private const int InitialStringTableCapacity = 32;
 
+            private HashSet<string> _projectFileDependencies;
+            private Dictionary<string, string> _targetNameToAliasMap;
             private ResolvePackageAssets _task;
             private BinaryWriter _writer;
             private LockFile _lockFile;
@@ -693,7 +711,8 @@ public CacheWriter(ResolvePackageAssets task)
                 _task = task;
                 _lockFile = new LockFileCache(task).GetLockFile(task.ProjectAssetsFile);
                 _packageResolver = NuGetPackageResolver.CreateResolver(_lockFile);
-
+                _targetNameToAliasMap = CreateTargetNameToAlisMap();
+                ReadProjectFileDependencies(string.IsNullOrEmpty(_task.TargetFramework) || !_targetNameToAliasMap.ContainsKey(_task.TargetFramework) ? null : _targetNameToAliasMap[_task.TargetFramework]);
 
                 //  If we are doing a design-time build, we do not want to fail the build if we can't find the
                 //  target framework and/or runtime identifier in the assets file.  This is because the design-time
@@ -735,8 +754,26 @@ public CacheWriter(ResolvePackageAssets task)
                 {
                     ComputePackageExclusions();
                 }
+
+                void ReadProjectFileDependencies(string frameworkAlias)
+                {
+                    _projectFileDependencies = _lockFile.GetProjectFileDependencySet(frameworkAlias);
+                }
             }
 
+            private Dictionary<string, string> CreateTargetNameToAlisMap() => _lockFile.Targets.ToDictionary(t => t.Name, t =>
+            {
+                var alias = _lockFile.GetLockFileTargetAlias(t);
+                if (string.IsNullOrEmpty(t.RuntimeIdentifier))
+                {
+                    return alias;
+                }
+                else
+                {
+                    return alias + "/" + t.RuntimeIdentifier;
+                }
+            });
+
             public void WriteToCacheFile()
             {
                 Directory.CreateDirectory(Path.GetDirectoryName(_task.ProjectAssetsCacheFile));
@@ -817,6 +854,7 @@ private void WriteItemGroups()
                 WriteItemGroup(WriteNativeLibraries);
                 WriteItemGroup(WritePackageDefinitions);
                 WriteItemGroup(WritePackageDependencies);
+                WriteItemGroup(WritePackageDependenciesBetweenPackages);
                 WriteItemGroup(WritePackageFolders);
                 WriteItemGroup(WriteReferenceDocumentationFiles);
                 WriteItemGroup(WriteResourceAssemblies);
@@ -1481,6 +1519,71 @@ private void WritePackageDependencies()
                 }
             }
 
+            private void WritePackageDependenciesBetweenPackages()
+            {
+                foreach(var target in _lockFile.Targets)
+                {
+                    GetPackageDependencies(target);
+                }
+
+                void GetPackageDependencies(LockFileTarget target)
+                {
+                    var resolvedPackageVersions = target.Libraries
+                    .ToDictionary(pkg => pkg.Name, pkg => pkg.Version.ToNormalizedString(), StringComparer.OrdinalIgnoreCase);
+
+                    string frameworkAlias = _targetNameToAliasMap[target.Name];
+
+                    var transitiveProjectRefs = new HashSet<string>(
+                        target.Libraries
+                            .Where(lib => lib.IsTransitiveProjectReference(_lockFile, ref _projectFileDependencies, frameworkAlias))
+                            .Select(pkg => pkg.Name),
+                        StringComparer.OrdinalIgnoreCase);
+
+                    foreach (var package in target.Libraries)
+                    {
+                        string packageId = $"{package.Name}/{package.Version.ToNormalizedString()}";
+
+                        if (_projectFileDependencies.Contains(package.Name))
+                        {
+                            WriteItem(packageId);
+                            WriteMetadata(MetadataKeys.ParentTarget, frameworkAlias); // Foreign Key
+                            WriteMetadata(MetadataKeys.ParentPackage, string.Empty); // Foreign Key
+                        }
+
+                        // get sub package dependencies
+                        GetDependencies(package, target.Name, resolvedPackageVersions, transitiveProjectRefs);
+                    }
+                }
+
+                void GetDependencies(
+                    LockFileTargetLibrary package,
+                    string targetName,
+                    Dictionary<string, string> resolvedPackageVersions,
+                    HashSet<string> transitiveProjectRefs)
+                {
+                    string packageId = $"{package.Name}/{package.Version.ToNormalizedString()}";
+                    string frameworkAlias = _targetNameToAliasMap[targetName];
+                    foreach (var deps in package.Dependencies)
+                    {
+                        if (!resolvedPackageVersions.TryGetValue(deps.Id, out string version))
+                        {
+                            continue;
+                        }
+
+                        string depsName = $"{deps.Id}/{version}";
+
+                        WriteItem(depsName);
+                        WriteMetadata(MetadataKeys.ParentTarget, frameworkAlias); // Foreign Key
+                        WriteMetadata(MetadataKeys.ParentPackage, packageId); // Foreign Key
+
+                        if (transitiveProjectRefs.Contains(deps.Id))
+                        {
+                            WriteMetadata(MetadataKeys.TransitiveProjectReference, "true");
+                        }
+                    }
+                }
+            }
+
             private void WriteResourceAssemblies()
             {
                 WriteItems(

src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.PackageDependencyResolution.targets

@@ -310,6 +310,7 @@ Copyright (c) .NET Foundation. All rights reserved.
       <Output TaskParameter="PackageFolders" ItemName="AssetsFilePackageFolder" />
       <Output TaskParameter="PackageDependencies" ItemName="PackageDependencies" />
       <Output TaskParameter="PackageDefinitions" ItemName="PackageDefinitions" />
+      <Output TaskParameter="PackageDependenciesBetweenPackages" ItemName="PackageDependencies" />
     </ResolvePackageAssets>
 
     <ItemGroup Condition="'$(CopyDebugSymbolFilesFromPackages)' == 'true'">