From d40435b1c460416768cc53a27091e57d948be171 Mon Sep 17 00:00:00 2001
From: "Eric St. John" <ericstj@microsoft.com>
Date: Sat, 27 Feb 2016 10:05:49 -0800
Subject: [PATCH] Exclude:compile for implementation dependencies

---
 ...rosoft.DotNet.Build.Tasks.Packaging.csproj |  1 +
 .../src/PackageFiles/Packaging.targets        | 21 ++++
 .../src/PromoteReferenceDependencies.cs       | 99 +++++++++++++++++++
 3 files changed, 121 insertions(+)
 create mode 100644 src/Microsoft.DotNet.Build.Tasks.Packaging/src/PromoteReferenceDependencies.cs

diff --git a/src/Microsoft.DotNet.Build.Tasks.Packaging/src/Microsoft.DotNet.Build.Tasks.Packaging.csproj b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/Microsoft.DotNet.Build.Tasks.Packaging.csproj
index 7c959dad6d..6bbd791a02 100644
--- a/src/Microsoft.DotNet.Build.Tasks.Packaging/src/Microsoft.DotNet.Build.Tasks.Packaging.csproj
+++ b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/Microsoft.DotNet.Build.Tasks.Packaging.csproj
@@ -19,6 +19,7 @@
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="PromoteReferenceDependencies.cs" />
     <Compile Include="CreateTrimDependencyGroups.cs" />
     <Compile Include="ApplyBaseLine.cs" />
     <Compile Include="EnsureOOBFramework.cs" />
diff --git a/src/Microsoft.DotNet.Build.Tasks.Packaging/src/PackageFiles/Packaging.targets b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/PackageFiles/Packaging.targets
index 9c1c461d39..5ba073d9cb 100644
--- a/src/Microsoft.DotNet.Build.Tasks.Packaging/src/PackageFiles/Packaging.targets
+++ b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/PackageFiles/Packaging.targets
@@ -102,6 +102,7 @@
   <UsingTask TaskName="GenerateNuSpec" AssemblyFile="$(PackagingTaskDir)Microsoft.DotNet.Build.Tasks.Packaging.dll"/>
   <UsingTask TaskName="NuGetPack" AssemblyFile="$(PackagingTaskDir)Microsoft.DotNet.Build.Tasks.Packaging.dll"/>
   <UsingTask TaskName="ApplyBaseLine" AssemblyFile="$(PackagingTaskDir)Microsoft.DotNet.Build.Tasks.Packaging.dll"/>
+  <UsingTask TaskName="PromoteReferenceDependencies" AssemblyFile="$(PackagingTaskDir)Microsoft.DotNet.Build.Tasks.Packaging.dll"/>
 
   <!-- Determine if we actually need to build for this architecture -->
   <!-- Packages can specifically control their architecture by specifying the PackagePlatforms
@@ -503,6 +504,26 @@
 
   <Target Name="GetNuGetPackageDependencies"
           DependsOnTargets="GetFilePackageReferences">
+    <PropertyGroup>
+      <!-- determine if we have any reference assets in the package (files in the ref folder) -->
+      <_containsReferenceAsset Condition="'%(File.IsReferenceAsset)' == 'true'">true</_containsReferenceAsset>
+    </PropertyGroup>
+
+    <ItemGroup Condition="'$(_containsReferenceAsset)' == 'true'">
+      <!-- If the package contains a reference asset, then make all non-reference dependencies
+           exclude compile assets, so as not to leak implementation dependencies into the compile
+           graph.-->
+      <FilePackageDependency>
+        <Exclude Condition="'%(FilePackageDependency.IsReferenceAsset)' != 'true'">Compile</Exclude>
+      </FilePackageDependency>
+    </ItemGroup>
+    
+    <!-- Promote reference dependencies to implementation TargetFrameworks -->
+    <PromoteReferenceDependencies Dependencies="@(FilePackageDependency)" Condition="'@(FilePackageDependency)' != ''">
+      <Output TaskParameter="PromotedDependencies" ItemName="FilePackageDependency" />
+    </PromoteReferenceDependencies>
+      
+    
    <!-- We can reduce the number of dependencies listed for any framework that has
         inbox implementations since that framework doesn't need the packages for
         compile/runtime.  This reduces the noise when consuming our packages in
diff --git a/src/Microsoft.DotNet.Build.Tasks.Packaging/src/PromoteReferenceDependencies.cs b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/PromoteReferenceDependencies.cs
new file mode 100644
index 0000000000..a3210ed2cf
--- /dev/null
+++ b/src/Microsoft.DotNet.Build.Tasks.Packaging/src/PromoteReferenceDependencies.cs
@@ -0,0 +1,99 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.Build.Framework;
+using Microsoft.Build.Utilities;
+using NuGet.Frameworks;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Microsoft.DotNet.Build.Tasks.Packaging
+{
+    /// <summary>
+    /// Promotes dependencies from reference (ref) assembly TargetFramework to the implementation (lib) assembly 
+    /// TargetFramework.  NuGet only ever chooses a single dependencyGroup from a package.  Often the TFM of the 
+    /// implementation and reference differ so in order to ensure the dependencies from the reference assembly are
+    /// also applicable in all circumstances that the implementation is applicable we need to copy the reference
+    /// dependencies to the implementation group.  Usually this is redundant since the implementation must expose
+    /// the surface area of the reference, but it is needed in two circumstances:
+    ///   1. The implementation is a facade and doesn't reference the contracts.
+    ///   2. We supress implementation dependencies with exclude=compile, but persist the reference dependencies.
+    /// </summary>
+    public class PromoteReferenceDependencies : PackagingTask
+    {
+        private const string IsReferenceMetadataName = "IsReferenceAsset";
+        private const string TargetFrameworkMetadataName = "TargetFramework";
+
+        [Required]
+        public ITaskItem[] Dependencies { get; set; }
+        
+        [Output]
+        public ITaskItem[] PromotedDependencies { get; set; }
+        
+        public override bool Execute()
+        {
+            List<ITaskItem> promotedDependencies = new List<ITaskItem>();
+
+            var actualDependencies = Dependencies.Where(d => d.ItemSpec != "_._").Select(d => new Dependency(d)).ToArray();
+
+            var implementationFxs = actualDependencies.Where(d => !d.IsReference).Select(d => d.TargetFramework).Distinct();
+
+            var referenceSets = actualDependencies.Where(d => d.IsReference).GroupBy(d => d.TargetFramework).ToDictionary(g => NuGetFramework.Parse(g.Key), g => g.ToArray());
+            var candidateFxs = referenceSets.Keys.ToArray();
+
+            if (candidateFxs.Length != 0)
+            {
+                foreach (var implementationFx in implementationFxs)
+                {
+                    NuGetFramework fx = NuGetFramework.Parse(implementationFx);
+                    if (referenceSets.ContainsKey(fx))
+                    {
+                        // if this implementation assembly fx  has a matching reference fx skip promotion
+                        continue;
+                    }
+
+                    var nearestReferenceFx = FrameworkUtilities.GetNearest(fx, candidateFxs);
+
+                    if (nearestReferenceFx == null)
+                    {
+                        // This should never happen and indicates a bug in the package.  If a package contains references,
+                        // all implementations should have an applicable reference assembly.
+                        Log.LogError($"Could not find applicable reference assembly for implementation framework {implementationFx} from reference frameworks {string.Join(", ", referenceSets.Keys)}");
+                    }
+
+                    foreach (var reference in referenceSets[nearestReferenceFx])
+                    {
+                        var promotedDependency = new TaskItem(reference.OriginalItem);
+                        promotedDependency.SetMetadata(TargetFrameworkMetadataName, implementationFx);
+
+                        promotedDependencies.Add(promotedDependency);
+                    }
+                }
+            }
+
+            PromotedDependencies = promotedDependencies.ToArray();
+
+            return !Log.HasLoggedErrors;
+        }
+
+        private class Dependency
+        {
+            public Dependency(ITaskItem item)
+            {
+                Id = item.ItemSpec;
+                bool isReference = false;
+                bool.TryParse(item.GetMetadata(IsReferenceMetadataName), out isReference);
+                IsReference = isReference;
+                TargetFramework = item.GetMetadata(TargetFrameworkMetadataName);
+                OriginalItem = item;
+            }
+
+            public string Id { get; }
+            public bool IsReference { get; }
+            public string TargetFramework { get; }
+
+            public ITaskItem OriginalItem { get; }
+        }
+    }
+}