Merge future to master

Common.props

@@ -28,7 +28,7 @@
     <!-- Reset $(BuildEpoch) whenever $(VersionPrefix) increments. We subtract this from YYYYMMDD portion of build
          number below to obtain the fourth part of file version that must fit in 16 bits. We can produce builds 
          for seven years from every epoch reset. -->
-    <VersionPrefix Condition="'$(VersionPrefix)' == ''">1.0.0</VersionPrefix>
+    <VersionPrefix Condition="'$(VersionPrefix)' == ''">1.1.0</VersionPrefix>
     <BuildEpoch>20170101</BuildEpoch>
     <VersionPrereleasePrefix Condition="'$(VersionPrereleasePrefix)' == ''">alpha</VersionPrereleasePrefix>
     <!-- When running on VSO (for official builds) use a real number. -->

TestAssets/TestProjects/NewtonsoftFilterProfile/NewtonsoftFilterProfile.csproj

@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <ItemGroup>
+    <PackageReference Include="Newtonsoft.Json">
+      <Version>9.0.1</Version>
+    </PackageReference>
+  </ItemGroup>
+</Project>

TestAssets/TestProjects/SimpleCache/SimpleCache.csproj

@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk" ToolsVersion="15.0">
+    <ItemGroup>
+        <PackageReference Include="System.Private.Uri" Version="4.4.0-beta-24821-02" />
+        <PackageReference Include="Microsoft.NETCore.CoreDisTools" Version="1.0.1-prerelease-00001" />
+  </ItemGroup>
+
+</Project>

TestAssets/TestProjects/UnmanagedCache/UnmanagedCache.csproj

@@ -0,0 +1,6 @@
+<Project Sdk="Microsoft.NET.Sdk" ToolsVersion="15.0">
+    <ItemGroup>
+        <PackageReference Include="Microsoft.NETCore.CoreDisTools" Version="1.0.1-prerelease-00001" />
+  </ItemGroup>
+
+</Project>

src/Tasks/Microsoft.NET.Build.Tasks.UnitTests/GivenAPublishAssembliesResolver.cs

@@ -34,6 +34,26 @@ public void ItResolvesAssembliesFromProjectLockFiles(string projectName, string
                 .BeEquivalentTo(expectedResolvedFiles);
         }
 
+        [Theory]
+        [MemberData("ProjectData1")]
+        public void ItResolvesAssembliesFromProjectLockFilesWithCacheLayout(string projectName, string runtime, object[] expectedResolvedFiles)
+        {
+            LockFile lockFile = TestLockFiles.GetLockFile(projectName);
+            ProjectContext projectContext = lockFile.CreateProjectContext(
+                FrameworkConstants.CommonFrameworks.NetCoreApp10,
+                runtime,
+                Constants.DefaultPlatformLibrary);
+
+            IEnumerable<ResolvedFile> resolvedFiles = new PublishAssembliesResolver(new MockPackageResolver())
+                .WithPreserveCacheLayout(true)
+                .Resolve(projectContext);
+
+            resolvedFiles
+                .Should()
+                .BeEquivalentTo(expectedResolvedFiles);
+
+        }
+
         public static IEnumerable<object[]> ProjectData
         {
             get
@@ -69,7 +89,7 @@ public static IEnumerable<object[]> ProjectData
                         "all.asset.types",
                         "osx.10.11-x64",
                         new object[] {
-                            CreateNativeResolvedFile("Libuv", "1.9.0", "runtimes/osx/native/libuv.dylib", destinationSubDirectory: null),
+                            CreateNativeResolvedFile("Libuv", "1.9.0", "runtimes/osx/native/libuv.dylib", destinationSubDirectory: null, preserveCacheLayout: false),
                             CreateResolvedFileForTFM("System.Spatial", "5.7.0", "portable-net45+wp8+win8+wpa"),
                             CreateResourceResolvedFile("System.Spatial", "5.7.0", "portable-net45+wp8+win8+wpa", "de"),
                             CreateResourceResolvedFile("System.Spatial", "5.7.0", "portable-net45+wp8+win8+wpa", "zh-Hant"),
@@ -79,42 +99,96 @@ public static IEnumerable<object[]> ProjectData
             }
         }
 
-        private static ResolvedFile CreateResolvedFileForTFM(string packageId, string version, string tfm)
+        public static IEnumerable<object[]> ProjectData1
         {
-            return CreateResolvedFile(packageId, version, $"lib/{tfm}/{packageId}.dll", null);
+            get
+            {
+                return new[]
+                {
+                    new object[] {
+                        "dotnet.new",
+                        null,
+                        new object[] { }
+                    },
+                    new object[] {
+                        "simple.dependencies",
+                        null,
+                        new object[] {
+                            CreateResolvedFileForTFM("Newtonsoft.Json", "9.0.1", "netstandard1.0", true),
+                            CreateResolvedFileForTFM("System.Runtime.Serialization.Primitives", "4.1.1", "netstandard1.3", true),
+                            CreateResolvedFileForTFM("System.Collections.NonGeneric", "4.0.1", "netstandard1.3", true),
+                        }
+                    },
+                    new object[] {
+                        "all.asset.types",
+                        null,
+                        new object[] {
+                            CreateNativeResolvedFile("Libuv", "1.9.0", "runtimes/osx/native/libuv.dylib", true),
+                            CreateNativeResolvedFile("Libuv", "1.9.0", "runtimes/win7-x64/native/libuv.dll", true),
+                            CreateResolvedFileForTFM("System.Spatial", "5.7.0", "portable-net45+wp8+win8+wpa", true),
+                            CreateResourceResolvedFile("System.Spatial", "5.7.0", "portable-net45+wp8+win8+wpa", "de", true),
+                            CreateResourceResolvedFile("System.Spatial", "5.7.0", "portable-net45+wp8+win8+wpa", "zh-Hant", true),
+                        }
+                    },
+                    new object[] {
+                        "all.asset.types",
+                        "osx.10.11-x64",
+                        new object[] {
+                            CreateNativeResolvedFile("Libuv", "1.9.0", "runtimes/osx/native/libuv.dylib", destinationSubDirectory: null, preserveCacheLayout: true),
+                            CreateResolvedFileForTFM("System.Spatial", "5.7.0", "portable-net45+wp8+win8+wpa", true),
+                            CreateResourceResolvedFile("System.Spatial", "5.7.0", "portable-net45+wp8+win8+wpa", "de", true),
+                            CreateResourceResolvedFile("System.Spatial", "5.7.0", "portable-net45+wp8+win8+wpa", "zh-Hant", true),
+                        }
+                    },
+                };
+            }
+        }
+        private static ResolvedFile CreateResolvedFileForTFM(string packageId, string version, string tfm, bool preserveCacheLayout = false)
+        {
+            return CreateResolvedFile(packageId, version, $"lib/{tfm}/{packageId}.dll", null, preserveCacheLayout, AssetType.Runtime);
         }
 
-        private static ResolvedFile CreateResourceResolvedFile(string packageId, string version, string tfm, string locale)
+        private static ResolvedFile CreateResourceResolvedFile(string packageId, string version, string tfm, string locale, bool preserveCacheLayout = false)
         {
-            return CreateResolvedFile(packageId, version, $"lib/{tfm}/{locale}/{packageId}.resources.dll", locale);
+            return CreateResolvedFile(packageId, version, $"lib/{tfm}/{locale}/{packageId}.resources.dll", locale, preserveCacheLayout, AssetType.Resources);
         }
 
-        private static ResolvedFile CreateNativeResolvedFile(string packageId, string version, string filePath)
+        private static ResolvedFile CreateNativeResolvedFile(string packageId, string version, string filePath, bool preserveCacheLayout = false)
         {
-            return CreateNativeResolvedFile(packageId, version, filePath, Path.GetDirectoryName(filePath));
+            return CreateNativeResolvedFile(packageId, version, filePath, Path.GetDirectoryName(filePath), preserveCacheLayout);
         }
 
         private static ResolvedFile CreateNativeResolvedFile(
             string packageId,
             string version,
             string filePath,
-            string destinationSubDirectory)
+            string destinationSubDirectory,
+            bool preserveCacheLayout)
         {
-            return CreateResolvedFile(packageId, version, filePath, destinationSubDirectory);
+            return CreateResolvedFile(packageId, version, filePath, destinationSubDirectory, preserveCacheLayout, AssetType.Native);
         }
 
         private static ResolvedFile CreateResolvedFile(
             string packageId,
             string version,
             string filePath,
-            string destinationSubDirectory)
+            string destinationSubDirectory,
+            bool preserveCacheLayout,
+            AssetType assetType)
         {
+            string packageRoot;
             string packageDirectory = new MockPackageResolver()
-                .GetPackageDirectory(packageId, NuGetVersion.Parse(version));
+                .GetPackageDirectory(packageId, NuGetVersion.Parse(version), out packageRoot);
+
+            assetType.Should().NotBe(AssetType.None);
 
+            string sourcepath = Path.Combine(packageDirectory, filePath);
+            string sourcedir = Path.GetDirectoryName(sourcepath);
+            string destinationSubDirPath = preserveCacheLayout ? sourcedir.Substring(packageRoot.Length): destinationSubDirectory;
             return new ResolvedFile(
-                Path.Combine(packageDirectory, filePath),
-                destinationSubDirectory);
+                sourcepath,
+                destinationSubDirPath,
+                assetType);
         }
     }
 }

src/Tasks/Microsoft.NET.Build.Tasks.UnitTests/Mocks/MockPackageResolver.cs

@@ -14,9 +14,14 @@ public MockPackageResolver(string root = "/root")
         {
             _root = root;
         }
-
         public string GetPackageDirectory(string packageId, NuGetVersion version)
         {
+            string packageRoot = null;
+            return GetPackageDirectory(packageId, version, out packageRoot);
+        }
+        public string GetPackageDirectory(string packageId, NuGetVersion version, out string packageRoot)
+        {
+            packageRoot = _root;
             return Path.Combine(_root, packageId, version.ToNormalizedString(), "path");
         }
     }

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

@@ -27,6 +27,9 @@ public class GenerateRuntimeConfigurationFiles : TaskBase
         [Required]
         public string TargetFramework { get; set; }
 
+        [Required]
+        public string TargetFrameworkMoniker { get; set; }
+
         [Required]
         public string RuntimeConfigPath { get; set; }
 
@@ -52,7 +55,7 @@ protected override void ExecuteCore()
         {
             LockFile lockFile = new LockFileCache(BuildEngine4).GetLockFile(AssetsFilePath);
             ProjectContext projectContext = lockFile.CreateProjectContext(
-                NuGetUtils.ParseFrameworkName(TargetFramework),
+                NuGetUtils.ParseFrameworkName(TargetFrameworkMoniker),
                 RuntimeIdentifier,
                 PlatformLibraryName);
 
@@ -93,6 +96,7 @@ private void AddFramework(RuntimeOptions runtimeOptions, ProjectContext projectC
                     framework.Version = platformLibrary.Version.ToNormalizedString();
 
                     runtimeOptions.Framework = framework;
+                    runtimeOptions.tfm = TargetFramework;
                 }
             }
         }

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

@@ -8,5 +8,6 @@ namespace Microsoft.NET.Build.Tasks
     public interface IPackageResolver
     {
         string GetPackageDirectory(string packageId, NuGetVersion version);
+        string GetPackageDirectory(string packageId, NuGetVersion version, out string packageRoot);
     }
 }

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

@@ -16,7 +16,8 @@ public static ProjectContext CreateProjectContext(
             this LockFile lockFile,
             NuGetFramework framework,
             string runtime,
-            string platformLibraryName)
+            string platformLibraryName,
+            LockFile filterlockFile = null)
         {
             if (lockFile == null)
             {
@@ -28,6 +29,12 @@ public static ProjectContext CreateProjectContext(
             }
 
             LockFileTarget lockFileTarget = lockFile.GetTarget(framework, runtime);
+            LockFileTarget filterlockFileTarget = null;
+
+            if (filterlockFile != null)
+            {
+                filterlockFileTarget = filterlockFile.GetTarget(framework, runtime);
+            }
 
             if (lockFileTarget == null)
             {
@@ -39,7 +46,7 @@ public static ProjectContext CreateProjectContext(
                 throw new BuildErrorException(Strings.AssetsFileMissingTarget, lockFile.Path, targetMoniker, framework.GetShortFolderName(), runtime);
             }
 
-            return new ProjectContext(lockFile, lockFileTarget, platformLibraryName);
+            return new ProjectContext(lockFile, lockFileTarget, platformLibraryName, filterlockFileTarget);
         }
 
         public static LockFileTargetLibrary GetLibrary(this LockFileTarget lockFileTarget, string libraryName)
@@ -76,6 +83,7 @@ public static Dictionary<string, string> GetProjectFileDependencies(this LockFil
 
             return projectDeps;
         }
+
 
         public static HashSet<string> GetPlatformExclusionList(
             this LockFileTarget lockFileTarget,

src/Tasks/Microsoft.NET.Build.Tasks/Microsoft.NET.Build.Tasks.csproj

@@ -144,6 +144,12 @@
     <None Include="build\Microsoft.NET.Publish.targets">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Include="build\Microsoft.NET.ComposeCache.targets">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Include="build\Microsoft.NET.CrossGen.targets">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Include="build\Microsoft.NET.TargetFrameworkInference.targets">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
@@ -168,4 +174,4 @@
     </EmbeddedResource>
   </ItemGroup>
   <Import Project="..\..\..\build\Targets\Signing.Imports.targets" />
-</Project>
+</Project>

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

@@ -25,9 +25,19 @@ public NuGetPackageResolver(string userPackageFolder, IEnumerable<string> fallba
         {
             _packagePathResolver = new FallbackPackagePathResolver(userPackageFolder, fallbackPackageFolders);
         }
-
         public string GetPackageDirectory(string packageId, NuGetVersion version)
         {
+            string  packageRoot = null;
+            return GetPackageDirectory(packageId, version, out packageRoot);
+        }
+        public string GetPackageDirectory(string packageId, NuGetVersion version, out string packageRoot)
+        {
+            packageRoot = null;
+            var pkginfo = _packagePathResolver.GetPackageInfo(packageId,version);
+            if (pkginfo != null)
+            {
+                packageRoot = pkginfo.PathResolver.GetVersionListPath("");  //TODO Remove Once Nuget is updated to use FallbackPackagePathInfo.PathResolver.RootPath
+            }
             return _packagePathResolver.GetPackageDirectory(packageId, version);
         }
 

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

@@ -12,6 +12,7 @@ namespace Microsoft.NET.Build.Tasks
     public class ProjectContext
     {
         private readonly LockFile _lockFile;
+        private readonly LockFileTarget _filterlockFileTarget;
         private readonly LockFileTarget _lockFileTarget;
         private readonly string _platformLibraryName;
 
@@ -21,9 +22,10 @@ public class ProjectContext
         public LockFile LockFile => _lockFile;
         public LockFileTarget LockFileTarget => _lockFileTarget;
 
-        public ProjectContext(LockFile lockFile, LockFileTarget lockFileTarget, string platformLibraryName)
+        public ProjectContext(LockFile lockFile, LockFileTarget lockFileTarget, string platformLibraryName, LockFileTarget filterlockFileTarget = null)
         {
             _lockFile = lockFile;
+            _filterlockFileTarget = filterlockFileTarget;
             _lockFileTarget = lockFileTarget;
             _platformLibraryName = platformLibraryName;
 
@@ -54,6 +56,14 @@ public IEnumerable<LockFileTargetLibrary> GetRuntimeLibraries(IEnumerable<string
                 allExclusionList.UnionWith(privateAssetsExclusionList);
             }
 
+            if(_filterlockFileTarget != null)
+            {
+                IEnumerable<LockFileTargetLibrary> filterLibraries = _filterlockFileTarget.Libraries;
+                Dictionary<string, LockFileTargetLibrary> filterLookup = filterLibraries.ToDictionary(e => e.Name, StringComparer.OrdinalIgnoreCase);
+
+                allExclusionList.UnionWith(GetIntersection(filterLookup, libraryLookup));
+            }
+
             return runtimeLibraries.Filter(allExclusionList).ToArray();
         }
 
@@ -171,5 +181,36 @@ public HashSet<string> GetPrivateAssetsExclusionList(
 
             return privateAssetsToExclude;
         }
+        private static HashSet<string> GetIntersection(
+          IDictionary<string, LockFileTargetLibrary> collection1,
+          IDictionary<string, LockFileTargetLibrary> collection2)
+        {
+            var exclusionList = new HashSet<string>();
+            var iterated = collection1;
+            var lookup = collection2;
+
+            if (collection1.Count > collection2.Count)
+            {
+                iterated = collection2;
+                lookup = collection1;
+            }
+            foreach (var entry in iterated)
+            {
+
+                LockFileTargetLibrary library;
+
+                if (lookup.TryGetValue(entry.Key, out library))
+                {
+                    LockFileTargetLibrary dependency = entry.Value;
+
+                    if (library.Version.Equals(dependency.Version))
+                    {
+                        exclusionList.Add(entry.Key);
+                    }
+                }
+            }
+
+            return exclusionList;
+        }
     }
 }