NativeAOT implement warning as errors as a compiler feature

src/coreclr/nativeaot/BuildIntegration/Microsoft.NETCore.Native.targets

@@ -28,6 +28,7 @@ The .NET Foundation licenses this file to you under the MIT license.
     <PublishTrimmed Condition="'$(PublishTrimmed)' == ''">true</PublishTrimmed>
     <IlcPgoOptimize Condition="'$(IlcPgoOptimize)' == '' and '$(OptimizationPreference)' == 'Speed'">true</IlcPgoOptimize>
     <RunILLink>false</RunILLink>
+    <IlcTreatWarningsAsErrors Condition="'$(IlcTreatWarningsAsErrors)' == ''">$(TreatWarningsAsErrors)</IlcTreatWarningsAsErrors>
     <_IsiOSLikePlatform Condition="'$(_targetOS)' == 'maccatalyst' or $(_targetOS.StartsWith('ios')) or $(_targetOS.StartsWith('tvos'))">true</_IsiOSLikePlatform>
     <_IsApplePlatform Condition="'$(_targetOS)' == 'osx' or '$(_IsiOSLikePlatform)' == 'true'">true</_IsApplePlatform>
   </PropertyGroup>
@@ -268,6 +269,9 @@ The .NET Foundation licenses this file to you under the MIT license.
       <IlcArg Condition="'$(_targetOS)' == 'win' and $(IlcMultiModule) != 'true' and '$(IlcGenerateWin32Resources)' != 'false' and '$(NativeLib)' != 'Static'" Include="--win32resourcemodule:%(ManagedBinary.Filename)" />
       <IlcArg Condition="$(IlcDumpIL) == 'true'" Include="--ildump:$(NativeIntermediateOutputPath)%(ManagedBinary.Filename).il" />
       <IlcArg Condition="$(NoWarn) != ''" Include='--nowarn:"$([MSBuild]::Escape($(NoWarn)).Replace(`%0A`, ``).Replace(`%0D`, ``))"' />
+      <IlcArg Condition="$(IlcTreatWarningsAsErrors) == 'true'" Include="--warnaserror" />
+      <IlcArg Condition="$(WarningsAsErrors) != ''" Include='--warnaserr:"$([MSBuild]::Escape($(WarningsAsErrors)).Replace(`%0A`, ``).Replace(`%0D`, ``))"' />
+      <IlcArg Condition="$(WarningsNotAsErrors) != ''" Include='--nowarnaserr:"$([MSBuild]::Escape($(WarningsNotAsErrors)).Replace(`%0A`, ``).Replace(`%0D`, ``))"' />
       <IlcArg Condition="$(TrimmerSingleWarn) == 'true'" Include="--singlewarn" />
       <IlcArg Condition="$(SuppressTrimAnalysisWarnings) == 'true'" Include="--notrimwarn" />
       <IlcArg Condition="$(SuppressAotAnalysisWarnings) == 'true'" Include="--noaotwarn" />

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/BodySubstitutionParser.cs

@@ -72,11 +72,15 @@ protected override void ProcessMethod(TypeDesc type, XPathNavigator methodNav, o
                     _methodSubstitutions.Add(method, BodySubstitution.ThrowingBody);
                     break;
                 case "stub":
-                    BodySubstitution stubBody;
+                    BodySubstitution stubBody = null;
                     if (method.Signature.ReturnType.IsVoid)
                         stubBody = BodySubstitution.EmptyBody;
                     else
-                        stubBody = BodySubstitution.Create(TryCreateSubstitution(method.Signature.ReturnType, GetAttribute(methodNav, "value")));
+                    {
+                        object substitution = TryCreateSubstitution(method.Signature.ReturnType, GetAttribute(methodNav, "value"));
+                        if (substitution != null)
+                            stubBody = BodySubstitution.Create(substitution);
+                    }
 
                     if (stubBody != null)
                     {

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Logger.cs

@@ -34,6 +34,9 @@ public class Logger
         private readonly HashSet<string> _trimWarnedAssemblies = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
         private readonly HashSet<string> _aotWarnedAssemblies = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
 
+        private readonly bool _treatWarningsAsErrors;
+        private readonly Dictionary<int, bool> _warningsAsErrors;
+
         public static Logger Null = new Logger(new TextLogWriter(TextWriter.Null), null, false);
 
         public bool IsVerbose { get; }
@@ -46,7 +49,9 @@ public Logger(
             bool singleWarn,
             IEnumerable<string> singleWarnEnabledModules,
             IEnumerable<string> singleWarnDisabledModules,
-            IEnumerable<string> suppressedCategories)
+            IEnumerable<string> suppressedCategories,
+            bool treatWarningsAsErrors,
+            IDictionary<int, bool> warningsAsErrors)
         {
             _logWriter = writer;
             IsVerbose = isVerbose;
@@ -55,17 +60,19 @@ public Logger(
             _singleWarnEnabledAssemblies = new HashSet<string>(singleWarnEnabledModules, StringComparer.OrdinalIgnoreCase);
             _singleWarnDisabledAssemblies = new HashSet<string>(singleWarnDisabledModules, StringComparer.OrdinalIgnoreCase);
             _suppressedCategories = new HashSet<string>(suppressedCategories, StringComparer.Ordinal);
+            _treatWarningsAsErrors = treatWarningsAsErrors;
+            _warningsAsErrors = new Dictionary<int, bool>(warningsAsErrors);
             _compilerGeneratedState = ilProvider == null ? null : new CompilerGeneratedState(ilProvider, this);
             _unconditionalSuppressMessageAttributeState = new UnconditionalSuppressMessageAttributeState(_compilerGeneratedState, this);
         }
 
-        public Logger(TextWriter writer, ILProvider ilProvider, bool isVerbose, IEnumerable<int> suppressedWarnings, bool singleWarn, IEnumerable<string> singleWarnEnabledModules, IEnumerable<string> singleWarnDisabledModules, IEnumerable<string> suppressedCategories)
-            : this(new TextLogWriter(writer), ilProvider, isVerbose, suppressedWarnings, singleWarn, singleWarnEnabledModules, singleWarnDisabledModules, suppressedCategories)
+        public Logger(TextWriter writer, ILProvider ilProvider, bool isVerbose, IEnumerable<int> suppressedWarnings, bool singleWarn, IEnumerable<string> singleWarnEnabledModules, IEnumerable<string> singleWarnDisabledModules, IEnumerable<string> suppressedCategories, bool treatWarningsAsErrors, IDictionary<int, bool> warningsAsErrors)
+            : this(new TextLogWriter(writer), ilProvider, isVerbose, suppressedWarnings, singleWarn, singleWarnEnabledModules, singleWarnDisabledModules, suppressedCategories, treatWarningsAsErrors, warningsAsErrors)
         {
         }
 
         public Logger(ILogWriter writer, ILProvider ilProvider, bool isVerbose)
-            : this(writer, ilProvider, isVerbose, Array.Empty<int>(), singleWarn: false, Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>())
+            : this(writer, ilProvider, isVerbose, Array.Empty<int>(), singleWarn: false, Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), false, new Dictionary<int, bool>())
         {
         }
 
@@ -155,10 +162,13 @@ internal bool IsWarningSuppressed(int code, MessageOrigin origin)
             return _unconditionalSuppressMessageAttributeState.IsSuppressed(code, origin);
         }
 
-        internal static bool IsWarningAsError(int _/*code*/)
+        internal bool IsWarningAsError(int warningCode)
         {
-            // TODO: warnaserror
-            return false;
+            bool value;
+            if (_treatWarningsAsErrors)
+                return !_warningsAsErrors.TryGetValue(warningCode, out value) || value;
+
+            return _warningsAsErrors.TryGetValue(warningCode, out value) && value;
         }
 
         internal bool IsSingleWarn(ModuleDesc owningModule, string messageSubcategory)

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/Logging/MessageContainer.cs

@@ -131,7 +131,7 @@ internal static MessageContainer CreateErrorMessage(MessageOrigin? origin, Diagn
             if (TryLogSingleWarning(context, code, origin, subcategory))
                 return null;
 
-            if (Logger.IsWarningAsError(code))
+            if (context.IsWarningAsError(code))
                 return new MessageContainer(MessageCategory.WarningAsError, text, code, subcategory, origin);
 
             return new MessageContainer(MessageCategory.Warning, text, code, subcategory, origin);
@@ -148,7 +148,7 @@ internal static MessageContainer CreateErrorMessage(MessageOrigin? origin, Diagn
             if (TryLogSingleWarning(context, (int)id, origin, subcategory))
                 return null;
 
-            if (Logger.IsWarningAsError((int)id))
+            if (context.IsWarningAsError((int)id))
                 return new MessageContainer(MessageCategory.WarningAsError, id, subcategory, origin, args);
 
             return new MessageContainer(MessageCategory.Warning, id, subcategory, origin, args);

src/coreclr/tools/aot/ILCompiler.Trimming.Tests/TestCasesRunner/ILCompilerOptions.cs

@@ -16,5 +16,8 @@ public class ILCompilerOptions
 		public List<string> Descriptors = new List<string> ();
 		public bool FrameworkCompilation;
 		public bool SingleWarn;
+		public List<string> SubstitutionFiles = new List<string> ();
+		public bool TreatWarningsAsErrors;
+		public Dictionary<int, bool> WarningsAsErrors = new Dictionary<int, bool> ();
 	}
 }

src/coreclr/tools/aot/ILCompiler.Trimming.Tests/TestCasesRunner/TrimmingArgumentBuilder.cs

@@ -147,6 +147,7 @@ public virtual void AddStripLinkAttributes (bool stripLinkAttributes)
 
 		public virtual void AddSubstitutions (string file)
 		{
+			Options.SubstitutionFiles.Add (file);
 		}
 
 		public virtual void AddLinkAttributes (string file)
@@ -161,6 +162,30 @@ public virtual void AddAdditionalArgument (string flag, string[] values)
 			else if (flag == "--singlewarn") {
 				Options.SingleWarn = true;
 			}
+			else if (flag.StartsWith("--warnaserror"))
+			{
+				if (flag == "--warnaserror" || flag == "--warnaserror+")
+				{
+					if (values.Length == 0)
+						Options.TreatWarningsAsErrors = true;
+					else
+					{
+						foreach (int warning in ProcessWarningCodes(values))
+							Options.WarningsAsErrors[warning] = true;
+					}
+
+				}
+				else if (flag == "--warnaserror-")
+				{
+					if (values.Length == 0)
+						Options.TreatWarningsAsErrors = false;
+					else
+					{
+						foreach (int warning in ProcessWarningCodes(values))
+							Options.WarningsAsErrors[warning] = false;
+					}
+				}
+			}
 		}
 
 		public virtual void ProcessTestInputAssembly (NPath inputAssemblyPath)
@@ -261,6 +286,23 @@ private static void AppendExpandedPaths (Dictionary<string, string> dictionary,
 			}
 		}
 
+		private static readonly char[] s_separator = new char[] { ',', ';', ' ' };
+
+		private static IEnumerable<int> ProcessWarningCodes(IEnumerable<string> warningCodes)
+		{
+			foreach (string value in warningCodes)
+			{
+				string[] values = value.Split(s_separator, StringSplitOptions.RemoveEmptyEntries);
+				foreach (string id in values)
+				{
+					if (!id.StartsWith("IL", StringComparison.Ordinal) || !ushort.TryParse(id.AsSpan(2), out ushort code))
+						continue;
+
+					yield return code;
+				}
+			}
+		}
+
 		public ILCompilerOptions Build ()
 		{
 			var options = Options;

src/coreclr/tools/aot/ILCompiler.Trimming.Tests/TestCasesRunner/TrimmingDriver.cs

@@ -7,6 +7,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Runtime.InteropServices;
+using System.Xml;
 using ILCompiler;
 using ILCompiler.Dataflow;
 using ILLink.Shared.TrimAnalysis;
@@ -84,15 +85,33 @@ public ILScanResults Trim (ILCompilerOptions options, TrimmingCustomizations? cu
 				options.SingleWarn,
 				singleWarnEnabledModules: Enumerable.Empty<string> (),
 				singleWarnDisabledModules: Enumerable.Empty<string> (),
-				suppressedCategories: Enumerable.Empty<string> ());
+				suppressedCategories: Enumerable.Empty<string> (),
+				treatWarningsAsErrors: options.TreatWarningsAsErrors,
+				warningsAsErrors: options.WarningsAsErrors);
 
 			foreach (var descriptor in options.Descriptors) {
 				if (!File.Exists (descriptor))
 					throw new FileNotFoundException ($"'{descriptor}' doesn't exist");
 				compilationRoots.Add (new ILCompiler.DependencyAnalysis.TrimmingDescriptorNode (descriptor));
 			}
-
-			ilProvider = new FeatureSwitchManager (ilProvider, logger, options.FeatureSwitches, default);
+
+			var featureSwitches = options.FeatureSwitches;
+			BodyAndFieldSubstitutions substitutions = default;
+			IReadOnlyDictionary<ModuleDesc, IReadOnlySet<string>>? resourceBlocks = default;
+			foreach (string substitutionFilePath in options.SubstitutionFiles)
+			{
+				using FileStream fs = File.OpenRead(substitutionFilePath);
+				substitutions.AppendFrom(BodySubstitutionsParser.GetSubstitutions(
+					logger, typeSystemContext, XmlReader.Create(fs), substitutionFilePath, featureSwitches));
+
+				fs.Seek(0, SeekOrigin.Begin);
+
+				resourceBlocks = ManifestResourceBlockingPolicy.UnionBlockings(resourceBlocks,
+					ManifestResourceBlockingPolicy.SubstitutionsReader.GetSubstitutions(
+						logger, typeSystemContext, XmlReader.Create(fs), substitutionFilePath, featureSwitches));
+			}
+
+			ilProvider = new FeatureSwitchManager(ilProvider, logger, featureSwitches, substitutions);
 
 			CompilerGeneratedState compilerGeneratedState = new CompilerGeneratedState (ilProvider, logger);
 

src/coreclr/tools/aot/ILCompiler/ILCompilerRootCommand.cs

@@ -129,6 +129,12 @@ internal sealed class ILCompilerRootCommand : CliRootCommand
             new("--singlewarnassembly") { DefaultValueFactory = _ => Array.Empty<string>(), Description = "Generate single AOT/trimming warning for given assembly" };
         public CliOption<string[]> SingleWarnDisabledAssemblies { get; } =
             new("--nosinglewarnassembly") { DefaultValueFactory = _ => Array.Empty<string>(), Description = "Expand AOT/trimming warnings for given assembly" };
+        public CliOption<bool> TreatWarningsAsErrors { get; } =
+            new("--warnaserror") { Description = "Treat warnings as errors" };
+        public CliOption<string[]> WarningsAsErrorsEnable { get; } =
+            new("--warnaserr") { Description = "Enable treating specific warnings as errors" };
+        public CliOption<string[]> WarningsAsErrorsDisable { get; } =
+            new("--nowarnaserr") { Description = "Disable treating specific warnings as errors" };
         public CliOption<string[]> DirectPInvokes { get; } =
             new("--directpinvoke") { DefaultValueFactory = _ => Array.Empty<string>(), Description = "PInvoke to call directly" };
         public CliOption<string[]> DirectPInvokeLists { get; } =
@@ -225,6 +231,9 @@ public ILCompilerRootCommand(string[] args) : base(".NET Native IL Compiler")
             Options.Add(NoAotWarn);
             Options.Add(SingleWarnEnabledAssemblies);
             Options.Add(SingleWarnDisabledAssemblies);
+            Options.Add(TreatWarningsAsErrors);
+            Options.Add(WarningsAsErrorsEnable);
+            Options.Add(WarningsAsErrorsDisable);
             Options.Add(DirectPInvokes);
             Options.Add(DirectPInvokeLists);
             Options.Add(MaxGenericCycleDepth);

src/coreclr/tools/aot/ILCompiler/Program.cs

@@ -75,8 +75,18 @@ public int Run()
 
             ILProvider ilProvider = new NativeAotILProvider();
 
+            Dictionary<int, bool> warningsAsErrors = new Dictionary<int, bool>();
+            foreach (int warning in ProcessWarningCodes(Get(_command.WarningsAsErrorsEnable)))
+            {
+                warningsAsErrors[warning] = true;
+            }
+            foreach (int warning in ProcessWarningCodes(Get(_command.WarningsAsErrorsDisable)))
+            {
+                warningsAsErrors[warning] = false;
+            }
             var logger = new Logger(Console.Out, ilProvider, Get(_command.IsVerbose), ProcessWarningCodes(Get(_command.SuppressedWarnings)),
-                Get(_command.SingleWarn), Get(_command.SingleWarnEnabledAssemblies), Get(_command.SingleWarnDisabledAssemblies), suppressedWarningCategories);
+                Get(_command.SingleWarn), Get(_command.SingleWarnEnabledAssemblies), Get(_command.SingleWarnDisabledAssemblies), suppressedWarningCategories,
+                Get(_command.TreatWarningsAsErrors), warningsAsErrors);
 
             // NativeAOT is full AOT and its pre-compiled methods can not be
             // thrown away at runtime if they mismatch in required ISAs or

src/tests/Directory.Build.targets

@@ -555,6 +555,8 @@
          so the default for the test tree is partial. -->
     <TrimMode Condition="'$(EnableAggressiveTrimming)' != 'true'">partial</TrimMode>
 
+    <IlcTreatWarningsAsErrors>false</IlcTreatWarningsAsErrors>
+
     <IlcToolsPath>$(CoreCLRILCompilerDir)</IlcToolsPath>
     <IlcToolsPath Condition="'$(TargetArchitecture)' != '$(BuildArchitecture)' or '$(TargetOS)' != '$(HostOS)' or '$(EnableNativeSanitizers)' != ''">$(CoreCLRCrossILCompilerDir)</IlcToolsPath>
     <IlcBuildTasksPath>$(CoreCLRILCompilerDir)netstandard/ILCompiler.Build.Tasks.dll</IlcBuildTasksPath>

src/tests/nativeaot/SmokeTests/TrimmingBehaviors/DeadCodeElimination.cs

@@ -625,6 +625,8 @@ private static void ThrowIfPresent(Type testType, string typeName)
         }
     }
 
+    [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2072:UnrecognizedReflectionPattern",
+        Justification = "That's the point")]
     private static void ThrowIfPresentWithUsableMethodTable(Type testType, string typeName)
     {
         Type t = GetTypeSecretly(testType, typeName);

src/tests/nativeaot/SmokeTests/UnitTests/Devirtualization.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Diagnostics.CodeAnalysis;
 
 class Devirtualization
 {
@@ -103,6 +104,7 @@ static void AssertEqual<T>(T expected, T actual)
         [MethodImpl(MethodImplOptions.NoInlining)]
         static void TestIntf2(IIntf2 o, int expected) => AssertEqual(expected, o.GetValue());
 
+        [UnconditionalSuppressMessage("AOT", "IL3050", Justification = "MakeGenericType - Intentional")]
         public static void Run()
         {
             TestIntf1(new Intf1Impl(), 123);

src/tests/nativeaot/SmokeTests/UnitTests/Generics.cs

@@ -5,7 +5,12 @@
 using System.Reflection;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
+using System.Diagnostics.CodeAnalysis;
 
+[UnconditionalSuppressMessage("Trimming", "IL2055", Justification = "MakeGenericType - Intentional")]
+[UnconditionalSuppressMessage("Trimming", "IL2060", Justification = "MakeGenericMethod - Intentional")]
+[UnconditionalSuppressMessage("AOT", "IL3050", Justification = "MakeGenericType/MakeGenericMethod - Intentional")]
+[UnconditionalSuppressMessage("AOT", "IL3054", Justification = "Generic expansion aborted - Intentional")]
 class Generics
 {
     internal static int Run()

src/tests/nativeaot/SmokeTests/UnitTests/Interfaces.cs

@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
+using System.Diagnostics.CodeAnalysis;
 
 public class Interfaces
 {
@@ -1225,6 +1226,7 @@ public static int CallIndirect()
 
         static Type s_fooType = typeof(Foo);
 
+        [UnconditionalSuppressMessage("AOT", "IL3050", Justification = "MakeGenericType - Intentional")]
         public static void Run()
         {
             Type t = typeof(FrobCaller<>).MakeGenericType(s_fooType);
@@ -1289,6 +1291,7 @@ class Atom { }
 
         static Type s_atomType = typeof(Atom);
 
+        [UnconditionalSuppressMessage("AOT", "IL3050", Justification = "MakeGenericType - Intentional")]
         public static void Run()
         {
             Type t = typeof(Wrapper<>).MakeGenericType(s_atomType);
@@ -1354,6 +1357,7 @@ class Atom : AtomBase { }
         static Type s_atomType = typeof(Atom);
         static Type s_atomBaseType = typeof(AtomBase);
 
+        [UnconditionalSuppressMessage("AOT", "IL3050", Justification = "MakeGenericType - Intentional")]
         public static void Run()
         {
             Type t = typeof(FrobCaller<,>).MakeGenericType(typeof(AbjectFail<AtomBase>), s_atomType);
@@ -1576,6 +1580,7 @@ class Gen<T> where T : IFoo
             public static string GrabCookie() => T.ImHungryGiveMeCookie();
         }
 
+        [UnconditionalSuppressMessage("AOT", "IL3050", Justification = "MakeGenericType - Intentional")]
         public static void Run()
         {
             var r = (string)typeof(Gen<>).MakeGenericType(typeof(Baz)).GetMethod("GrabCookie").Invoke(null, Array.Empty<object>());
@@ -1612,6 +1617,7 @@ class Gen<T> where T : IFoo
             public static string GrabCookie() => T.ImHungryGiveMeCookie();
         }
 
+        [UnconditionalSuppressMessage("AOT", "IL3050", Justification = "MakeGenericType - Intentional")]
         public static void Run()
         {
             Activator.CreateInstance(typeof(Baz<>).MakeGenericType(typeof(Atom1)));

src/tools/illink/test/ILLink.RoslynAnalyzer.Tests/generated/ILLink.RoslynAnalyzer.Tests.Generator/ILLink.RoslynAnalyzer.Tests.TestCaseGenerator/WarningsTests.g.cs

@@ -87,6 +87,12 @@ public Task CanWarnAsError ()
 			return RunTest (allowMissingWarnings: true);
 		}
 
+		[Fact]
+		public Task CanWarnAsErrorGlobal ()
+		{
+			return RunTest (allowMissingWarnings: true);
+		}
+
 		[Fact]
 		public Task InvalidWarningVersion ()
 		{

src/tools/illink/test/Mono.Linker.Tests.Cases/Warnings/CanWarnAsError.cs

@@ -4,7 +4,6 @@
 namespace Mono.Linker.Tests.Cases.Warnings
 {
 	[ExpectNonZeroExitCode (1)]
-	[IgnoreTestCase ("Ignore in NativeAOT, see https://github.com/dotnet/runtime/issues/82447", IgnoredBy = Tool.NativeAot)]
 	[SkipKeptItemsValidation]
 	[SetupLinkerSubstitutionFile ("CanWarnAsErrorSubstitutions.xml")]
 	[SetupLinkerArgument ("--verbose")]