Add output PackageDependenciesDesignTime to cache file

Author: ocalles

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

@@ -162,6 +162,30 @@ public sealed class ResolvePackageAssets : TaskBase
         /// </summary>
         public bool DesignTimeBuild { get; set; }
 
+        /// <summary>
+        /// Eg: "Microsoft.NETCore.App;NETStandard.Library"
+        /// </summary>
+        [Required]
+        public string DefaultImplicitPackages { get; set; }
+
+        /// <summary>
+        /// Items with metadata "ParentTarget" and "ParentPackage", which allows determining the hierarchy of package references.
+        /// </summary>
+        [Required]
+        public ITaskItem[] InputPackageDependencies { get; set; }
+
+        /// <summary>
+        /// Information about each package in the project, with metadata:
+        /// - Name = "MetadataExtractor"
+        /// - Path = "metadataextractor/1.0.0"
+        /// - ResolvedPath = "C:\Users\drnoakes\.nuget\packages\metadataextractor\1.0.0"
+        /// - Type = "package"
+        /// - Version = "2.3.0"
+        /// - DiagnosticLevel = ""
+        /// </summary>
+        [Required]
+        public ITaskItem[] PackageDefinitions { get; set; }
+
         #endregion
 
         #region Output Items
@@ -238,6 +262,17 @@ public sealed class ResolvePackageAssets : TaskBase
         [Output]
         public ITaskItem[] PackageDependencies { get; private set; }
 
+        /// <summary>
+        /// Filters and projects items produced by <see cref="ResolvePackageDependencies"/> for consumption by
+        /// the dependencies tree, via design-time builds.
+        /// </summary>
+        /// <remarks>
+        /// Changes to the implementation of output must be coordinated with <c>PackageRuleHandler</c>
+        /// in the dotnet/project-system repo.
+        /// </remarks>
+        [Output]
+        public ITaskItem[] PackageDependenciesDesignTime { get; private set; }
+
         /// <summary>
         /// List of symbol files (.pdb) related to NuGet packages.
         /// </summary>
@@ -311,7 +346,7 @@ public sealed class ResolvePackageAssets : TaskBase
         ////////////////////////////////////////////////////////////////////////////////////////////////////
 
         private const int CacheFormatSignature = ('P' << 0) | ('K' << 8) | ('G' << 16) | ('A' << 24);
-        private const int CacheFormatVersion = 11;
+        private const int CacheFormatVersion = 12;
         private static readonly Encoding TextEncoding = Encoding.UTF8;
         private const int SettingsHashLength = 256 / 8;
         private HashAlgorithm CreateSettingsHash() => SHA256.Create();
@@ -343,6 +378,7 @@ private void ReadItemGroups()
                 FrameworkReferences = reader.ReadItemGroup();
                 NativeLibraries = reader.ReadItemGroup();
                 PackageDependencies = reader.ReadItemGroup();
+                PackageDependenciesDesignTime = reader.ReadItemGroup();
                 PackageFolders = reader.ReadItemGroup();
                 ReferenceDocumentationFiles = reader.ReadItemGroup();
                 ResourceAssemblies = reader.ReadItemGroup();
@@ -660,6 +696,7 @@ private ITaskItem ReadItem()
         internal sealed class CacheWriter : IDisposable
         {
             private const int InitialStringTableCapacity = 32;
+            private const string ResolvedMetadata = "Resolved";
 
             private ResolvePackageAssets _task;
             private BinaryWriter _writer;
@@ -814,6 +851,7 @@ private void WriteItemGroups()
                 WriteItemGroup(WriteFrameworkReferences);
                 WriteItemGroup(WriteNativeLibraries);
                 WriteItemGroup(WritePackageDependencies);
+                WriteItemGroup(WritePackageDependenciesDesignTime);
                 WriteItemGroup(WritePackageFolders);
                 WriteItemGroup(WriteReferenceDocumentationFiles);
                 WriteItemGroup(WriteResourceAssemblies);
@@ -1408,6 +1446,111 @@ private void WritePackageDependencies()
                 }
             }
 
+            private void WritePackageDependenciesDesignTime()
+            {
+                var implicitPackageReferences = GetImplicitPackageReferences(_task.DefaultImplicitPackages);
+
+                // We have two types of data:
+                //
+                // 1) "PackageDependencies" which place a package in a given target/hierarchy
+                // 2) "PackageDefinitions" which provide general metadata about a package
+                //
+                // First, we scan PackageDependencies to build the set of packages in our target.
+
+                var allowItemSpecs = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+                foreach (var dependency in _task.InputPackageDependencies)
+                {
+                    if (dependency.HasMetadataValue(MetadataKeys.ParentPackage))
+                    {
+                        // ignore non-top-level packages (those with ParentPackage)
+                        continue;
+                    }
+
+                    var target = dependency.GetMetadata(MetadataKeys.ParentTarget);
+
+                    if (!StringComparer.OrdinalIgnoreCase.Equals(target, _task.TargetFramework))
+                    {
+                        // skip dependencies for other targets
+                        continue;
+                    }
+
+                    allowItemSpecs.Add(dependency.ItemSpec);
+                }
+
+                // Second, find PackageDefinitions that match our allowed item specs
+
+                var outputItems = new List<ITaskItem>(allowItemSpecs.Count);
+
+                foreach (var packageDef in _task.PackageDefinitions)
+                {
+                    if (!allowItemSpecs.Contains(packageDef.ItemSpec))
+                    {
+                        // We are not interested in this definition (not top-level, or wrong target)
+                        continue;
+                    }
+
+                    var dependencyType = GetDependencyType(packageDef.GetMetadata(MetadataKeys.Type));
+
+                    if (dependencyType == DependencyType.Package ||
+                        dependencyType == DependencyType.Unresolved)
+                    {
+                        var name = packageDef.GetMetadata(MetadataKeys.Name);
+
+                        if (string.IsNullOrEmpty(name))
+                        {
+                            // Name is required
+                            continue;
+                        }
+
+                        var version = packageDef.GetMetadata(MetadataKeys.Version) ?? string.Empty;
+                        var resolvedPath = packageDef.GetMetadata(MetadataKeys.ResolvedPath);
+                        var resolved = !string.IsNullOrEmpty(resolvedPath);
+                        var path = (resolved
+                            ? resolvedPath
+                            : packageDef.GetMetadata(MetadataKeys.Path)) ?? string.Empty;
+                        var isImplicitlyDefined = implicitPackageReferences.Contains(name);
+                        var diagnosticLevel = packageDef.GetMetadata(MetadataKeys.DiagnosticLevel) ?? string.Empty;
+
+                        WriteItem(packageDef.ItemSpec);
+                        WriteMetadata(MetadataKeys.Name, name);
+                        WriteMetadata(MetadataKeys.Version, version);
+                        WriteMetadata(MetadataKeys.Path, path);
+                        WriteMetadata(MetadataKeys.IsImplicitlyDefined, isImplicitlyDefined.ToString());
+                        WriteMetadata(MetadataKeys.DiagnosticLevel, diagnosticLevel);
+                        WriteMetadata(ResolvedMetadata, resolved.ToString());
+                    }
+                }
+
+                static HashSet<string> GetImplicitPackageReferences(string defaultImplicitPackages)
+                {
+                    var implicitPackageReferences = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+                    if (string.IsNullOrEmpty(defaultImplicitPackages))
+                    {
+                        return implicitPackageReferences;
+                    }
+
+                    var packageNames = defaultImplicitPackages.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
+                    if (packageNames.Length == 0)
+                    {
+                        return implicitPackageReferences;
+                    }
+
+                    foreach (var packageReference in packageNames)
+                    {
+                        implicitPackageReferences.Add(packageReference);
+                    }
+
+                    return implicitPackageReferences;
+                }
+
+                static DependencyType GetDependencyType(string dependencyTypeString)
+                {
+                    Enum.TryParse(dependencyTypeString, ignoreCase: true, out DependencyType dependencyType);
+                    return dependencyType;
+                }
+            }
+
             private void WriteResourceAssemblies()
             {
                 WriteItems(