From e406311a7ce8573a197585a52f2a25a744dcf5ff Mon Sep 17 00:00:00 2001 From: Sven Boemer Date: Tue, 3 Oct 2023 23:01:23 +0000 Subject: [PATCH 1/4] Add extra test coverage --- .../GivenThatWeWantToPublishASingleFileApp.cs | 37 +++++++++++++++++++ .../GivenThatWeWantToPublishAnAotApp.cs | 31 ++++++++++++++++ .../GivenThatWeWantToRunILLink.cs | 29 +++++++++++---- 3 files changed, 90 insertions(+), 7 deletions(-) diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishASingleFileApp.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishASingleFileApp.cs index f1300ba8eed8..c0da33a9275e 100644 --- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishASingleFileApp.cs +++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishASingleFileApp.cs @@ -633,8 +633,45 @@ public void ILLink_analyzer_warnings_are_produced_using_EnableSingleFileAnalyzer .And.HaveStdOutContaining("(10,13): warning IL3001"); } + + [RequiresMSBuildVersionTheory("17.0.0.32901")] + [InlineData("netcoreapp2.1", true)] + [InlineData("netcoreapp3.0", false)] + [InlineData("netcoreapp3.1", false)] + [InlineData("net5.0", false)] + [InlineData("net6.0", false)] + [InlineData("net7.0", false)] + public void PublishSingleFile_fails_for_unsupported_target_framework(string targetFramework, bool shouldFail) + { + var testProject = new TestProject() + { + Name = "HelloWorld", + IsExe = true, + TargetFrameworks = targetFramework + }; + testProject.AdditionalProperties["PublishSingleFile"] = "true"; + testProject.AdditionalProperties["SelfContained"] = "true"; + testProject.AdditionalProperties["NoWarn"] = "NETSDK1138"; // Silence warning about targeting EOL TFMs + var testAsset = _testAssetsManager.CreateTestProject(testProject, identifier: targetFramework); + + var publishCommand = new PublishCommand(testAsset); + var result = publishCommand.Execute(RuntimeIdentifier); + if (shouldFail) + { + result.Should().Fail() + .And.HaveStdOutContaining(Strings.PublishSingleFileRequiresVersion30); + } + else + { + result.Should().Pass() + .And.NotHaveStdOutContaining("warning"); + } + } + [RequiresMSBuildVersionTheory("17.8.0")] [InlineData("netstandard2.0", true)] + [InlineData("net5.0", false)] + [InlineData("net6.0", false)] [InlineData("netstandard2.0;net5.0", true)] // None of these TFMs are supported for single-file [InlineData("netstandard2.0;net6.0", false)] // Net6.0 is the min TFM supported for single-file and targeting. [InlineData("netstandard2.0;net8.0", true)] // Net8.0 is supported for single-file, but leaves a "gap" for the supported net6./net7.0 TFMs. diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAotApp.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAotApp.cs index 60c761787054..73d579e2c482 100644 --- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAotApp.cs +++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAotApp.cs @@ -3,6 +3,7 @@ using System.Reflection.PortableExecutable; using Microsoft.DotNet.Cli.Utils; +using Microsoft.NET.Build.Tasks; using Newtonsoft.Json.Linq; using static Microsoft.NET.Publish.Tests.PublishTestUtils; @@ -590,13 +591,43 @@ public void IsAotCompatible_implies_enable_analyzers(string targetFramework) .And.NotHaveStdOutContaining("warning IL3002"); } + [RequiresMSBuildVersionTheory("17.0.0.32901")] + [InlineData("net5.0", true)] + [InlineData("net6.0", true)] + [InlineData("net7.0", false)] + public void PublishAot_fails_for_unsupported_target_framework(string targetFramework, bool shouldFail) + { + var rid = EnvironmentInfo.GetCompatibleRid(targetFramework); + + var testProject = new TestProject() + { + Name = "HelloWorld", + TargetFrameworks = targetFramework + }; + testProject.AdditionalProperties["PublishAot"] = "true"; + var testAsset = _testAssetsManager.CreateTestProject(testProject, identifier: targetFramework); + + var publishCommand = new PublishCommand(testAsset); + var result = publishCommand.Execute($"/p:RuntimeIdentifier={rid}"); + if (shouldFail) { + result.Should().Fail() + .And.HaveStdOutContaining(Strings.AotUnsupportedTargetFramework); + } else { + result.Should().Pass() + .And.NotHaveStdOutContaining("warning"); + } + } + [RequiresMSBuildVersionTheory("17.8.0")] [InlineData("netstandard2.0", true)] + [InlineData("net6.0", false)] + [InlineData("net7.0", false)] [InlineData("netstandard2.0;net5.0", true)] // None of these TFMs are supported for AOT [InlineData("netstandard2.0;net7.0", false)] // Net7.0 is the min TFM supported for AOT and targeting. [InlineData("netstandard2.0;net8.0", true)] // Net8.0 is supported for AOT, but leaves a "gap" for the supported net7.0 TFMs. [InlineData("alias-ns2", true)] [InlineData("alias-n6", false)] + [InlineData("alias-n7", false)] [InlineData("alias-n7;alias-n8", false)] // If all TFMs are supported, there's no warning even though the project uses aliases. [InlineData("alias-ns2;alias-n7", true)] // This is correctly multi-targeted, but the logic can't detect this due to the alias so it still warns. public void IsAotCompatible_warns_when_expected_for_not_correctly_multitarget_libraries(string targetFrameworks, bool shouldWarn) diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToRunILLink.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToRunILLink.cs index f0b4eb23abf4..d59edbe6a0ec 100644 --- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToRunILLink.cs +++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToRunILLink.cs @@ -148,25 +148,39 @@ public void PublishTrimmed_fails_when_no_matching_pack_is_found(string targetFra } [RequiresMSBuildVersionTheory("17.0.0.32901")] - [InlineData("netcoreapp2.0")] - [InlineData("netcoreapp2.1")] - [InlineData("netstandard2.1")] - public void PublishTrimmed_fails_for_unsupported_target_framework(string targetFramework) + [InlineData("netcoreapp2.0", true)] + [InlineData("netcoreapp2.1", true)] + [InlineData("netstandard2.1", true)] + [InlineData("netcoreapp3.0", false)] + [InlineData("netcoreapp3.1", false)] + [InlineData("net5.0", false)] + [InlineData("net6.0", false)] + public void PublishTrimmed_fails_for_unsupported_target_framework(string targetFramework, bool shouldFail) { var projectName = "HelloWorld"; var rid = EnvironmentInfo.GetCompatibleRid(targetFramework); var testProject = CreateTestProjectForILLinkTesting(targetFramework, projectName); + testProject.AdditionalProperties["PublishTrimmed"] = "true"; + testProject.AdditionalProperties["NoWarn"] = "NETSDK1138"; // Silence warning about targeting EOL TFMs var testAsset = _testAssetsManager.CreateTestProject(testProject, identifier: targetFramework); var publishCommand = new PublishCommand(testAsset); - publishCommand.Execute($"/p:RuntimeIdentifier={rid}", "/p:PublishTrimmed=true") - .Should().Fail() - .And.HaveStdOutContaining($"error {Strings.PublishTrimmedRequiresVersion30}"); + var result = publishCommand.Execute($"/p:RuntimeIdentifier={rid}"); + if (shouldFail) { + result.Should().Fail() + .And.HaveStdOutContaining($"error {Strings.PublishTrimmedRequiresVersion30}"); + } else { + result.Should().Pass() + .And.NotHaveStdOutContaining("warning"); + } } [RequiresMSBuildVersionTheory("17.8.0")] [InlineData("netstandard2.0", true)] [InlineData("netstandard2.1", true)] + [InlineData("netcoreapp3.1", false)] + [InlineData("net5.0", false)] + [InlineData("net6.0", false)] [InlineData("netstandard2.0;net5.0", true)] // None of these TFMs are supported for trimming [InlineData("netstandard2.0;net6.0", false)] // Net6.0 is the min TFM supported for trimming and targeting. [InlineData("netstandard2.0;net8.0", true)] // Net8.0 is supported for trimming, but leaves a "gap" for the supported net6.0/net7.0 TFMs. @@ -181,6 +195,7 @@ public void IsTrimmable_warns_when_expected_for_not_correctly_multitargeted_libr var testProject = CreateTestProjectForILLinkTesting(targetFrameworks, projectName); testProject.AdditionalProperties["IsTrimmable"] = "true"; + testProject.AdditionalProperties["NoWarn"] = "NETSDK1138"; // Silence warning about targeting EOL TFMs var testAsset = _testAssetsManager.CreateTestProject(testProject, identifier: targetFrameworks) .WithProjectChanges(AddTargetFrameworkAliases); From 8a2e1911ec3f3613d315760f44e23abb71c1e973 Mon Sep 17 00:00:00 2001 From: Sven Boemer Date: Tue, 3 Oct 2023 23:53:23 +0000 Subject: [PATCH 2/4] Remove support for referencing ILLink analyzers on old TFMs Up to .NET 7, the analyzers versioned with the SDK (so you would always get the latest analyzers). This allowed using the analyzers (and related options which enable the analyzers) even on older TFMs. https://github.com/dotnet/sdk/pull/32045 changed to versioning the analyzers with the target framework, but still allowed use of the analyzers on target frameworks where the .NET 7 ILLink pack was made available for backwards compatibility. This change removes such backwards compat by treating the analyzers as unsupported for target frameworks before the framework was annotated with the relevant attributes. PublishTrimmed/PublishSingleFile/PublishAot used to enable the corresponding analyzers. With this change, we now need to avoid failing PublishTrimmed/PublishSingleFile for older TFMs that supported these publish options, but don't support the analyzers. --- .../ProcessFrameworkReferences.cs | 22 +++++++++++++++++++ .../targets/Microsoft.NET.Publish.targets | 12 ++++++---- .../Microsoft.NET.Sdk.Analyzers.targets | 18 ++++++++++++--- ...T.Sdk.FrameworkReferenceResolution.targets | 3 +++ .../GivenThatWeWantToPublishASingleFileApp.cs | 2 +- .../GivenThatWeWantToPublishAnAotApp.cs | 4 ++-- .../GivenThatWeWantToRunILLink.cs | 4 ++-- 7 files changed, 53 insertions(+), 12 deletions(-) diff --git a/src/Tasks/Microsoft.NET.Build.Tasks/ProcessFrameworkReferences.cs b/src/Tasks/Microsoft.NET.Build.Tasks/ProcessFrameworkReferences.cs index 11ccb15937a8..73ec82b63a7f 100644 --- a/src/Tasks/Microsoft.NET.Build.Tasks/ProcessFrameworkReferences.cs +++ b/src/Tasks/Microsoft.NET.Build.Tasks/ProcessFrameworkReferences.cs @@ -51,10 +51,14 @@ public class ProcessFrameworkReferences : TaskBase public bool EnableAotAnalyzer { get; set; } + public string FirstTargetFrameworkVersionToSupportAotAnalyzer { get; set; } + public bool PublishTrimmed { get; set; } public bool IsTrimmable { get; set; } + public string FirstTargetFrameworkVersionToSupportTrimAnalyzer { get; set; } + public bool SilenceIsTrimmableUnsupportedWarning { get; set; } public string MinNonEolTargetFrameworkForTrimming { get; set; } @@ -63,6 +67,8 @@ public class ProcessFrameworkReferences : TaskBase public bool EnableSingleFileAnalyzer { get; set; } + public string FirstTargetFrameworkVersionToSupportSingleFileAnalyzer { get; set; } + public bool SilenceEnableSingleFileAnalyzerUnsupportedWarning { get; set; } public string MinNonEolTargetFrameworkForSingleFile { get; set; } @@ -828,6 +834,22 @@ private ToolPackSupport AddToolPack( packagesToDownload.Add(runtimePackToDownload); } + if (toolPackType is ToolPackType.ILLink) + { + // The ILLink tool pack is available for some TargetFrameworks where we nonetheless consider + // IsTrimmable/IsAotCompatible/EnableSingleFile to be unsupported, because the framework + // was not annotated with the attributes. + var firstTargetFrameworkVersionToSupportAotAnalyzer = NormalizeVersion(new Version(FirstTargetFrameworkVersionToSupportAotAnalyzer)); + if ((IsAotCompatible || EnableAotAnalyzer) && normalizedTargetFrameworkVersion < firstTargetFrameworkVersionToSupportAotAnalyzer) + return ToolPackSupport.UnsupportedForTargetFramework; + var firstTargetFrameworkVersionToSupportSingleFileAnalyzer = NormalizeVersion(new Version(FirstTargetFrameworkVersionToSupportSingleFileAnalyzer)); + if (EnableSingleFileAnalyzer && normalizedTargetFrameworkVersion < firstTargetFrameworkVersionToSupportSingleFileAnalyzer) + return ToolPackSupport.UnsupportedForTargetFramework; + var firstTargetFrameworkVersionToSupportTrimAnalyzer = NormalizeVersion(new Version(FirstTargetFrameworkVersionToSupportTrimAnalyzer)); + if ((IsTrimmable || EnableTrimAnalyzer) && normalizedTargetFrameworkVersion < firstTargetFrameworkVersionToSupportTrimAnalyzer) + return ToolPackSupport.UnsupportedForTargetFramework; + } + // Packs with RID-agnostic build packages that contain MSBuild targets. if (toolPackType is not ToolPackType.Crossgen2 && EnableRuntimePackDownload) { diff --git a/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Publish.targets b/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Publish.targets index d2538c54a990..5ddb865d66b9 100644 --- a/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Publish.targets +++ b/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Publish.targets @@ -22,6 +22,14 @@ Copyright (c) .NET Foundation. All rights reserved. true true + + <_FirstTargetFrameworkToSupportTrimming>net6.0 + <_FirstTargetFrameworkToSupportAot>net7.0 + <_FirstTargetFrameworkToSupportSingleFile>net6.0 + + <_FirstTargetFrameworkVersionToSupportTrimAnalyzer>$([MSBuild]::GetTargetFrameworkVersion('$(_FirstTargetFrameworkToSupportTrimming)')) + <_FirstTargetFrameworkVersionToSupportAotAnalyzer>$([MSBuild]::GetTargetFrameworkVersion('$(_FirstTargetFrameworkToSupportAot)')) + <_FirstTargetFrameworkVersionToSupportSingleFileAnalyzer>$([MSBuild]::GetTargetFrameworkVersion('$(_FirstTargetFrameworkToSupportSingleFile)')) @@ -43,7 +51,6 @@ Copyright (c) .NET Foundation. All rights reserved. <_RequiresILLinkPack Condition="'$(_RequiresILLinkPack)' == ''">false - - <_FirstTargetFrameworkToSupportTrimming>net6.0 - <_FirstTargetFrameworkToSupportAot>net7.0 - <_FirstTargetFrameworkToSupportSingleFile>net6.0 <_MinNonEolTargetFrameworkForTrimming>$(_MinimumNonEolSupportedNetCoreTargetFramework) <_MinNonEolTargetFrameworkForSingleFile>$(_MinimumNonEolSupportedNetCoreTargetFramework) diff --git a/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Sdk.Analyzers.targets b/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Sdk.Analyzers.targets index 6b71c3d0422c..00ba8b71b046 100644 --- a/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Sdk.Analyzers.targets +++ b/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Sdk.Analyzers.targets @@ -74,14 +74,26 @@ Copyright (c) .NET Foundation. All rights reserved. true + ( + ('$(PublishSingleFile)' == 'true' And '$(TargetFrameworkIdentifier)' == '.NETCoreApp' And $([MSBuild]::VersionGreaterThanOrEquals($(_TargetFrameworkVersionWithoutV), '$(_FirstTargetFrameworkVersionToSupportSingleFileAnalyzer)'))) Or + ('$(PublishAot)' == 'true' And '$(TargetFrameworkIdentifier)' == '.NETCoreApp' And $([MSBuild]::VersionGreaterThanOrEquals($(_TargetFrameworkVersionWithoutV), '$(_FirstTargetFrameworkVersionToSupportAotAnalyzer)'))) Or + '$(IsAotCompatible)' == 'true' + )">true true + ( + ('$(PublishTrimmed)' == 'true' And '$(TargetFrameworkIdentifier)' == '.NETCoreApp' And $([MSBuild]::VersionGreaterThanOrEquals($(_TargetFrameworkVersionWithoutV), '$(_FirstTargetFrameworkVersionToSupportTrimAnalyzer)'))) Or + ('$(PublishAot)' == 'true' And '$(TargetFrameworkIdentifier)' == '.NETCoreApp' And $([MSBuild]::VersionGreaterThanOrEquals($(_TargetFrameworkVersionWithoutV), '$(_FirstTargetFrameworkVersionToSupportAotAnalyzer)'))) Or + '$(IsTrimmable)' == 'true' + )">true - true + true false diff --git a/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Sdk.FrameworkReferenceResolution.targets b/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Sdk.FrameworkReferenceResolution.targets index 0cf0b6cc48c4..63be500baa07 100644 --- a/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Sdk.FrameworkReferenceResolution.targets +++ b/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Sdk.FrameworkReferenceResolution.targets @@ -105,12 +105,15 @@ Copyright (c) .NET Foundation. All rights reserved. SilenceIsAotCompatibleUnsupportedWarning="$(_SilenceIsAotCompatibleUnsupportedWarning)" MinNonEolTargetFrameworkForAot="$(_MinNonEolTargetFrameworkForAot)" EnableAotAnalyzer="$(EnableAotAnalyzer)" + FirstTargetFrameworkVersionToSupportAotAnalyzer="$(_FirstTargetFrameworkVersionToSupportAotAnalyzer)" PublishTrimmed="$(PublishTrimmed)" IsTrimmable="$(IsTrimmable)" + FirstTargetFrameworkVersionToSupportTrimAnalyzer="$(_FirstTargetFrameworkVersionToSupportTrimAnalyzer)" SilenceIsTrimmableUnsupportedWarning="$(_SilenceIsTrimmableUnsupportedWarning)" MinNonEolTargetFrameworkForTrimming="$(_MinNonEolTargetFrameworkForTrimming)" EnableTrimAnalyzer="$(EnableTrimAnalyzer)" EnableSingleFileAnalyzer="$(EnableSingleFileAnalyzer)" + FirstTargetFrameworkVersionToSupportSingleFileAnalyzer="$(_FirstTargetFrameworkVersionToSupportSingleFileAnalyzer)" SilenceEnableSingleFileAnalyzerUnsupportedWarning="$(_SilenceEnableSingleFileAnalyzerUnsupportedWarning)" MinNonEolTargetFrameworkForSingleFile="$(_MinNonEolTargetFrameworkForSingleFile)" AotUseKnownRuntimePackForTarget="$(PublishAotUsingRuntimePack)" diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishASingleFileApp.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishASingleFileApp.cs index c0da33a9275e..5c29ab485a47 100644 --- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishASingleFileApp.cs +++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishASingleFileApp.cs @@ -670,7 +670,7 @@ public void PublishSingleFile_fails_for_unsupported_target_framework(string targ [RequiresMSBuildVersionTheory("17.8.0")] [InlineData("netstandard2.0", true)] - [InlineData("net5.0", false)] + [InlineData("net5.0", true)] [InlineData("net6.0", false)] [InlineData("netstandard2.0;net5.0", true)] // None of these TFMs are supported for single-file [InlineData("netstandard2.0;net6.0", false)] // Net6.0 is the min TFM supported for single-file and targeting. diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAotApp.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAotApp.cs index 73d579e2c482..a8f5c70b3bfe 100644 --- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAotApp.cs +++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAotApp.cs @@ -620,13 +620,13 @@ public void PublishAot_fails_for_unsupported_target_framework(string targetFrame [RequiresMSBuildVersionTheory("17.8.0")] [InlineData("netstandard2.0", true)] - [InlineData("net6.0", false)] + [InlineData("net6.0", true)] [InlineData("net7.0", false)] [InlineData("netstandard2.0;net5.0", true)] // None of these TFMs are supported for AOT [InlineData("netstandard2.0;net7.0", false)] // Net7.0 is the min TFM supported for AOT and targeting. [InlineData("netstandard2.0;net8.0", true)] // Net8.0 is supported for AOT, but leaves a "gap" for the supported net7.0 TFMs. [InlineData("alias-ns2", true)] - [InlineData("alias-n6", false)] + [InlineData("alias-n6", true)] [InlineData("alias-n7", false)] [InlineData("alias-n7;alias-n8", false)] // If all TFMs are supported, there's no warning even though the project uses aliases. [InlineData("alias-ns2;alias-n7", true)] // This is correctly multi-targeted, but the logic can't detect this due to the alias so it still warns. diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToRunILLink.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToRunILLink.cs index d59edbe6a0ec..79e752789ded 100644 --- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToRunILLink.cs +++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToRunILLink.cs @@ -178,8 +178,8 @@ public void PublishTrimmed_fails_for_unsupported_target_framework(string targetF [RequiresMSBuildVersionTheory("17.8.0")] [InlineData("netstandard2.0", true)] [InlineData("netstandard2.1", true)] - [InlineData("netcoreapp3.1", false)] - [InlineData("net5.0", false)] + [InlineData("netcoreapp3.1", true)] + [InlineData("net5.0", true)] [InlineData("net6.0", false)] [InlineData("netstandard2.0;net5.0", true)] // None of these TFMs are supported for trimming [InlineData("netstandard2.0;net6.0", false)] // Net6.0 is the min TFM supported for trimming and targeting. From 15312841913f2f63c9d3b0e608d74c2f382cbbeb Mon Sep 17 00:00:00 2001 From: Sven Boemer Date: Wed, 4 Oct 2023 16:32:22 +0000 Subject: [PATCH 3/4] Fix testcase The breaking change shows up in this testcase, which was designed to demonstrate how one could work around the ProcessFrameworkReferences logic to reference the latest version of the analyzer in a netstandard project. The workaround now requires an additional setting. --- .../TrimmableNetstandardLibrary.csproj | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/Assets/TestProjects/TrimmableNetstandardLibrary/TrimmableNetstandardLibrary.csproj b/src/Assets/TestProjects/TrimmableNetstandardLibrary/TrimmableNetstandardLibrary.csproj index 0f3ed99f87eb..1afebd15f542 100644 --- a/src/Assets/TestProjects/TrimmableNetstandardLibrary/TrimmableNetstandardLibrary.csproj +++ b/src/Assets/TestProjects/TrimmableNetstandardLibrary/TrimmableNetstandardLibrary.csproj @@ -12,6 +12,10 @@ + + + <_FirstTargetFrameworkVersionToSupportTrimAnalyzer>2.0 + Date: Wed, 4 Oct 2023 23:16:13 +0000 Subject: [PATCH 4/4] Skip AOT on OSX for old TFMs --- .../GivenThatWeWantToPublishAnAotApp.cs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAotApp.cs b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAotApp.cs index a8f5c70b3bfe..26eb016f5e44 100644 --- a/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAotApp.cs +++ b/src/Tests/Microsoft.NET.Publish.Tests/GivenThatWeWantToPublishAnAotApp.cs @@ -597,6 +597,12 @@ public void IsAotCompatible_implies_enable_analyzers(string targetFramework) [InlineData("net7.0", false)] public void PublishAot_fails_for_unsupported_target_framework(string targetFramework, bool shouldFail) { + if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) + { + // OSX wasn't supported before net8 + return; + } + var rid = EnvironmentInfo.GetCompatibleRid(targetFramework); var testProject = new TestProject()