[Core] Adding attributes to support Native AOT compiling

eng/Directory.Build.Common.targets

@@ -200,6 +200,7 @@
     <Compile Include="$(AzureCoreSharedSources)FixedDelayWithNoJitterStrategy.cs" LinkBase="Shared/Core" />
     <Compile Include="$(AzureCoreSharedSources)OperationPoller.cs" LinkBase="Shared/Core" />
     <Compile Include="$(AzureCoreSharedSources)ClientDiagnostics.cs" LinkBase="Shared/Core" />
+		<Compile Include="$(AzureCoreSharedSources)TrimmingAttribute.cs" LinkBase="Shared/Core" />
     <Compile Include="$(AzureCoreSharedSources)DiagnosticScope.cs" LinkBase="Shared/Core" />
     <Compile Include="$(AzureCoreSharedSources)DiagnosticScopeFactory.cs" LinkBase="Shared/Core" />
     <Compile Include="$(AzureCoreSharedSources)HttpMessageSanitizer.cs" LinkBase="Shared/Core" />

sdk/core/Azure.Core/aotcompatibility/AotCompatibilityTestApp.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net7.0</TargetFramework>
+    <PublishAot>true</PublishAot>
+    <TrimmerSingleWarn>false</TrimmerSingleWarn>
+    <IsTestSupportProject>true</IsTestSupportProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\src\Azure.Core.csproj" />
+    <ProjectReference Include="..\..\..\monitor\Azure.Monitor.OpenTelemetry.Exporter\src\Azure.Monitor.OpenTelemetry.Exporter.csproj" />
+
+    <TrimmerRootAssembly Include="Azure.Monitor.OpenTelemetry.Exporter" />
+
+    <!-- Update this dependency to its latest, which has all the annotations -->
+    <PackageReference Include="Microsoft.Extensions.Logging.Configuration" Version="8.0.0-preview.7.23375.6" />
+  </ItemGroup>
+
+</Project>

sdk/core/Azure.Core/aotcompatibility/Program.cs

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+using Azure.Core;
+using Azure.Core.Pipeline;
+using Azure.Monitor.OpenTelemetry.Exporter;
+using System;
+
+namespace Azure.Core.Tests.AotCompatibility.TestApp
+{
+    internal class Program
+    {
+        public static void Main(string[] args)
+        {
+            System.Console.WriteLine("Hello, World!");
+        }
+    }
+}

sdk/core/Azure.Core/aotcompatibility/test-aot-compat.ps1

@@ -0,0 +1,28 @@
+param([string]$targetNetFramework)
+
+$rootDirectory = Split-Path $PSScriptRoot -Parent
+$publishOutput = dotnet publish -nodeReuse:false /p:UseSharedCompilation=false /p:ExposeExperimentalFeatures=true
+
+$actualWarningCount = 0
+
+foreach ($line in $($publishOutput -split "`r`n"))
+{
+    if ($line -like "*analysis warning IL*")
+    {
+        Write-Host $line
+
+        $actualWarningCount += 1
+    }
+}
+
+Write-Host "Actual warning count is:", $actualWarningCount
+$expectedWarningCount = 43
+
+$testPassed = 0
+if ($actualWarningCount -ne $expectedWarningCount)
+{
+    $testPassed = 1
+    Write-Host "Actual warning count:", actualWarningCount, "is not as expected. Expected warning count is:", $expectedWarningCount
+}
+
+Exit $testPassed

sdk/core/Azure.Core/api/Azure.Core.net5.0.cs

@@ -546,8 +546,11 @@ protected RequestContent() { }
         public static Azure.Core.RequestContent Create(byte[] bytes) { throw null; }
         public static Azure.Core.RequestContent Create(byte[] bytes, int index, int length) { throw null; }
         public static Azure.Core.RequestContent Create(System.IO.Stream stream) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("This method uses reflection-based serialization which is incompatible with trimming. Try using one of the 'Create' overloads that doesn't wrap a serialized version of an object.")]
         public static Azure.Core.RequestContent Create(object serializable) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("This method uses reflection-based serialization which is incompatible with trimming. Try using one of the 'Create' overloads that doesn't wrap a serialized version of an object.")]
         public static Azure.Core.RequestContent Create(object serializable, Azure.Core.Serialization.JsonPropertyNames propertyNameFormat, string dateTimeFormat = "o") { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("This method uses reflection-based serialization which is incompatible with trimming. Try using one of the 'Create' overloads that doesn't wrap a serialized version of an object.")]
         public static Azure.Core.RequestContent Create(object serializable, Azure.Core.Serialization.ObjectSerializer? serializer) { throw null; }
         public static Azure.Core.RequestContent Create(System.ReadOnlyMemory<byte> bytes) { throw null; }
         public static Azure.Core.RequestContent Create(string content) { throw null; }

sdk/core/Azure.Core/api/Azure.Core.net6.0.cs

@@ -546,8 +546,11 @@ protected RequestContent() { }
         public static Azure.Core.RequestContent Create(byte[] bytes) { throw null; }
         public static Azure.Core.RequestContent Create(byte[] bytes, int index, int length) { throw null; }
         public static Azure.Core.RequestContent Create(System.IO.Stream stream) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("This method uses reflection-based serialization which is incompatible with trimming. Try using one of the 'Create' overloads that doesn't wrap a serialized version of an object.")]
         public static Azure.Core.RequestContent Create(object serializable) { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("This method uses reflection-based serialization which is incompatible with trimming. Try using one of the 'Create' overloads that doesn't wrap a serialized version of an object.")]
         public static Azure.Core.RequestContent Create(object serializable, Azure.Core.Serialization.JsonPropertyNames propertyNameFormat, string dateTimeFormat = "o") { throw null; }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("This method uses reflection-based serialization which is incompatible with trimming. Try using one of the 'Create' overloads that doesn't wrap a serialized version of an object.")]
         public static Azure.Core.RequestContent Create(object serializable, Azure.Core.Serialization.ObjectSerializer? serializer) { throw null; }
         public static Azure.Core.RequestContent Create(System.ReadOnlyMemory<byte> bytes) { throw null; }
         public static Azure.Core.RequestContent Create(string content) { throw null; }
@@ -1026,6 +1029,7 @@ protected HttpPipelinePolicy() { }
         protected static void ProcessNext(Azure.Core.HttpMessage message, System.ReadOnlyMemory<Azure.Core.Pipeline.HttpPipelinePolicy> pipeline) { }
         protected static System.Threading.Tasks.ValueTask ProcessNextAsync(Azure.Core.HttpMessage message, System.ReadOnlyMemory<Azure.Core.Pipeline.HttpPipelinePolicy> pipeline) { throw null; }
     }
+    [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods)]
     public abstract partial class HttpPipelineSynchronousPolicy : Azure.Core.Pipeline.HttpPipelinePolicy
     {
         protected HttpPipelineSynchronousPolicy() { }
@@ -1084,6 +1088,7 @@ public AbstractHierarchyDeserializerAttribute([System.Diagnostics.CodeAnalysis.D
         [System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicConstructors | System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicConstructors)]
         public System.Type TypeToActivate { get { throw null; } }
     }
+    [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("This class utilizes reflection-based JSON serialization and deserialization which is not compatible with trimming.")]
     [System.Diagnostics.DebuggerDisplayAttribute("{DebuggerDisplay,nq}")]
     public sealed partial class DynamicData : System.Dynamic.IDynamicMetaObjectProvider, System.IDisposable
     {
@@ -1128,6 +1133,7 @@ public partial interface IModelSerializable<out T>
         T Deserialize(System.BinaryData data, Azure.Core.Serialization.ModelSerializerOptions options);
         System.BinaryData Serialize(Azure.Core.Serialization.ModelSerializerOptions options);
     }
+    [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("This class uses reflection-based JSON serialization and deserialization that is not compatible with trimming.")]
     public partial class JsonObjectSerializer : Azure.Core.Serialization.ObjectSerializer, Azure.Core.Serialization.IMemberNameConverter
     {
         public JsonObjectSerializer() { }

sdk/core/Azure.Core/src/Diagnostics/AzureCoreEventSource.cs

@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.Tracing;
+using System.Diagnostics.CodeAnalysis;
 using System.Text;
 
 namespace Azure.Core.Diagnostics
@@ -231,6 +232,7 @@ public void ErrorResponseContentTextBlock(string requestId, int blockNumber, str
         }
 
         [Event(RequestRetryingEvent, Level = EventLevel.Informational, Message = "Request [{0}] attempt number {1} took {2:00.0}s")]
+        [UnconditionalSuppressMessage("ReflectionAnalysis", "IL2026", Justification = "WriteEvent is used with primitive types.")]
         public void RequestRetrying(string requestId, int retryNumber, double seconds)
         {
             WriteEvent(RequestRetryingEvent, requestId, retryNumber, seconds);

sdk/core/Azure.Core/src/DynamicData/DynamicData.cs

@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.ComponentModel;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Reflection;
 using System.Text.Json;
@@ -20,6 +21,9 @@ namespace Azure.Core.Serialization
     /// This and related types are not intended to be mocked.
     /// </summary>
     [DebuggerDisplay("{DebuggerDisplay,nq}")]
+#if !NET5_0
+    [RequiresUnreferencedCode("This class utilizes reflection-based JSON serialization and deserialization which is not compatible with trimming.")]
+#endif
     [JsonConverter(typeof(DynamicDataJsonConverter))]
     public sealed partial class DynamicData : IDisposable
     {
@@ -344,6 +348,9 @@ public override int GetHashCode()
         [DebuggerBrowsable(DebuggerBrowsableState.Never)]
         private string DebuggerDisplay => _element.DebuggerDisplay;
 
+#if !NET5_0
+        [RequiresUnreferencedCode("This class utilizes reflection-based JSON serialization and deserialization which is not compatible with trimming.")]
+#endif
         private class DynamicDataJsonConverter : JsonConverter<DynamicData>
         {
             public override DynamicData Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)

sdk/core/Azure.Core/src/DynamicData/MutableJsonChange.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
 using System.Text.Json;
 
 namespace Azure.Core.Json
@@ -11,6 +12,7 @@ internal struct MutableJsonChange
     {
         private JsonElement? _serializedValue;
         private readonly JsonSerializerOptions _serializerOptions;
+        internal const string SerializationRequiresUnreferencedCode = "This method utilizes reflection-based JSON serialization which is not compatible with trimming.";
 
         public MutableJsonChange(string path,
             int index,
@@ -108,6 +110,7 @@ internal bool IsGreaterThan(ReadOnlySpan<char> otherPath)
             return Path.AsSpan().SequenceCompareTo(otherPath) > 0;
         }
 
+        [RequiresUnreferencedCode(SerializationRequiresUnreferencedCode)]
         internal string AsString()
         {
             return GetSerializedValue().ToString() ?? "null";

sdk/core/Azure.Core/src/DynamicData/MutableJsonDocument.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Buffers;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Text;
 using System.Text.Json;
@@ -13,6 +14,9 @@ namespace Azure.Core.Json
     /// <summary>
     /// A mutable representation of a JSON value.
     /// </summary>
+#if !NET5_0
+    [RequiresUnreferencedCode("This class utilizes reflection-based JSON serialization and deserialization which is not compatible with trimming.")]
+#endif
     [JsonConverter(typeof(MutableJsonDocumentConverter))]
     internal sealed partial class MutableJsonDocument : IDisposable
     {
@@ -206,6 +210,9 @@ private MutableJsonDocument(JsonDocument document, ReadOnlyMemory<byte> utf8Json
             _serializerOptions = serializerOptions ?? new JsonSerializerOptions();
         }
 
+#if !NET5_0
+        [RequiresUnreferencedCode("This class utilizes reflection-based JSON serialization and deserialization which is not compatible with trimming.")]
+#endif
         private class MutableJsonDocumentConverter : JsonConverter<MutableJsonDocument>
         {
             public override MutableJsonDocument Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)

sdk/core/Azure.Core/src/DynamicData/MutableJsonElement.WriteTo.cs

@@ -3,12 +3,14 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Text.Json;
 
 namespace Azure.Core.Json
 {
     internal partial struct MutableJsonElement
     {
+        [RequiresUnreferencedCode(SerializationRequiresUnreferencedCode)]
         internal void WriteTo(Utf8JsonWriter writer)
         {
             WriteElement(_path, _highWaterMark, _element, writer);
@@ -30,6 +32,7 @@ internal void WriteTo(Utf8JsonWriter writer, string format)
             }
         }
 
+        [RequiresUnreferencedCode(SerializationRequiresUnreferencedCode)]
         private void WriteElement(string path, int highWaterMark, JsonElement element, Utf8JsonWriter writer)
         {
             if (Changes.TryGetChange(path, highWaterMark, out MutableJsonChange change))
@@ -84,6 +87,7 @@ private void WriteElement(string path, int highWaterMark, JsonElement element, U
             element.WriteTo(writer);
         }
 
+        [RequiresUnreferencedCode(SerializationRequiresUnreferencedCode)]
         private void WriteObject(string path, int highWaterMark, JsonElement element, Utf8JsonWriter writer)
         {
             writer.WriteStartObject();
@@ -111,6 +115,7 @@ private void WriteObject(string path, int highWaterMark, JsonElement element, Ut
             writer.WriteEndObject();
         }
 
+        [RequiresUnreferencedCode(SerializationRequiresUnreferencedCode)]
         private void WriteArray(string path, int highWaterMark, JsonElement element, Utf8JsonWriter writer)
         {
             writer.WriteStartArray();