Address a few AOT warnings in Azure.Core (Azure#46611)

sbomer · web-flow · commit f868683c9930 · 2024-10-30T18:30:34.000-04:00
* Address a few AOT warnings in Azure.Core

* Fix apicompat
diff --git a/sdk/core/Azure.Core/api/Azure.Core.net6.0.cs b/sdk/core/Azure.Core/api/Azure.Core.net6.0.cs
@@ -95,8 +95,10 @@ public HttpAuthorization(string scheme, string parameter) { }
     }
     public partial class JsonPatchDocument
     {
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("JsonObjectSerializer uses reflection-based JSON serialization and deserialization that is not compatible with trimming.")]
         public JsonPatchDocument() { }
         public JsonPatchDocument(Azure.Core.Serialization.ObjectSerializer serializer) { }
+        [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("JsonObjectSerializer uses reflection-based JSON serialization and deserialization that is not compatible with trimming.")]
         public JsonPatchDocument(System.ReadOnlyMemory<byte> rawDocument) { }
         public JsonPatchDocument(System.ReadOnlyMemory<byte> rawDocument, Azure.Core.Serialization.ObjectSerializer serializer) { }
         public void AppendAddRaw(string path, string rawJsonValue) { }
diff --git a/sdk/core/Azure.Core/src/DynamicData/DynamicData.AllowList.cs b/sdk/core/Azure.Core/src/DynamicData/DynamicData.AllowList.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 using System.Text.Json;
 
@@ -13,6 +14,7 @@ public partial class DynamicData
     {
         internal class AllowList
         {
+            [RequiresUnreferencedCode("Reflection over unknown type")]
             public static void AssertAllowedValue<T>(T value)
             {
                 if (value == null)
@@ -26,6 +28,7 @@ public static void AssertAllowedValue<T>(T value)
                 }
             }
 
+            [RequiresUnreferencedCode("Reflection over unknown type")]
             private static bool IsAllowedValue<T>(T value)
             {
                 if (value == null)
@@ -63,6 +66,7 @@ private static bool IsAllowedType(Type type)
                     type == typeof(DynamicData);
             }
 
+            [RequiresUnreferencedCode("Reflection over unknown type")]
             private static bool IsAllowedCollectionValue<T>(Type type, T value)
             {
                 return
@@ -71,6 +75,7 @@ private static bool IsAllowedCollectionValue<T>(Type type, T value)
                     IsAllowedDictionaryValue(type, value);
             }
 
+            [RequiresUnreferencedCode("Reflection over unknown type")]
             private static bool IsAllowedArrayValue<T>(Type type, T value)
             {
                 if (value is not Array array)
@@ -92,6 +97,7 @@ private static bool IsAllowedArrayValue<T>(Type type, T value)
                 return IsAllowedEnumerableValue(elementType, array);
             }
 
+            [RequiresUnreferencedCode("Reflection over unknown type")]
             private static bool IsAllowedListValue<T>(Type type, T value)
             {
                 if (value == null)
@@ -118,6 +124,7 @@ private static bool IsAllowedListValue<T>(Type type, T value)
                 return IsAllowedEnumerableValue(genericArgument, (IEnumerable)value);
             }
 
+            [RequiresUnreferencedCode("Reflection over unknown type")]
             private static bool IsAllowedDictionaryValue<T>(Type type, T value)
             {
                 if (value == null)
@@ -149,6 +156,7 @@ private static bool IsAllowedDictionaryValue<T>(Type type, T value)
                 return IsAllowedEnumerableValue(genericArguments[1], ((IDictionary)value).Values);
             }
 
+            [RequiresUnreferencedCode("Reflection over unknown type")]
             private static bool IsAllowedEnumerableValue(Type elementType, IEnumerable enumerable)
             {
                 foreach (var item in enumerable)
@@ -174,7 +182,8 @@ private static bool IsAllowedEnumerableValue(Type elementType, IEnumerable enume
                 return true;
             }
 
-            private static bool IsAllowedAnonymousValue<T>(Type type, T value)
+            [RequiresUnreferencedCode("Reflection over unknown type")]
+            private static bool IsAllowedAnonymousValue<T>([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type type, T value)
             {
                 if (!IsAnonymousType(type))
                 {
diff --git a/sdk/core/Azure.Core/src/JsonPatchDocument.cs b/sdk/core/Azure.Core/src/JsonPatchDocument.cs
@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.ObjectModel;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -25,6 +26,8 @@ public class JsonPatchDocument
         /// <summary>
         /// Initializes a new instance of <see cref="JsonPatchDocument"/> that uses <see cref="JsonObjectSerializer"/> as the default serializer.
         /// </summary>
+        [RequiresUnreferencedCode("JsonObjectSerializer uses reflection-based JSON serialization and deserialization that is not compatible with trimming.")]
+        [RequiresDynamicCode("JsonObjectSerializer uses reflection-based JSON serialization and deserialization that is not compatible with trimming.")]
         public JsonPatchDocument() : this(default(ReadOnlyMemory<byte>))
         {
         }
@@ -41,6 +44,8 @@ public JsonPatchDocument(ObjectSerializer serializer): this(default(ReadOnlyMemo
         /// Initializes a new instance of <see cref="JsonPatchDocument"/>
         /// </summary>
         /// <param name="rawDocument">The binary representation of JSON Patch document.</param>
+        [RequiresUnreferencedCode("JsonObjectSerializer uses reflection-based JSON serialization and deserialization that is not compatible with trimming.")]
+        [RequiresDynamicCode("JsonObjectSerializer uses reflection-based JSON serialization and deserialization that is not compatible with trimming.")]
         public JsonPatchDocument(ReadOnlyMemory<byte> rawDocument) : this(rawDocument, new JsonObjectSerializer())
         {
         }
diff --git a/sdk/core/Azure.Core/tests/compatibility/ExpectedAotWarnings.txt b/sdk/core/Azure.Core/tests/compatibility/ExpectedAotWarnings.txt
@@ -2,9 +2,6 @@ ILC : Trim analysis warning IL2026: Azure\.Core\.Serialization\.DynamicData: Usi
 ILC : AOT analysis warning IL3050: Azure\.Core\.Serialization\.DynamicData: Using member 'Azure\.Core\.Serialization\.DynamicData\.DynamicDataJsonConverter\.DynamicDataJsonConverter\(\)' which has 'RequiresDynamicCodeAttribute' can break functionality when AOT compiling\. Using DynamicData or DynamicDataConverter is not compatible with trimming due to reflection-based serialization
 ILC : Trim analysis warning IL2026: Azure\.Core\.Json\.MutableJsonDocument: Using member 'Azure\.Core\.Json\.MutableJsonDocument\.MutableJsonDocumentConverter\.MutableJsonDocumentConverter\(\)' which has 'RequiresUnreferencedCodeAttribute' can break functionality when trimming application code\. Using MutableJsonDocument or MutableJsonDocumentConverter is not compatible with trimming due to reflection-based serialization
 ILC : AOT analysis warning IL3050: Azure\.Core\.Json\.MutableJsonDocument: Using member 'Azure\.Core\.Json\.MutableJsonDocument\.MutableJsonDocumentConverter\.MutableJsonDocumentConverter\(\)' which has 'RequiresDynamicCodeAttribute' can break functionality when AOT compiling\. Using MutableJsonDocument or MutableJsonDocumentConverter is not compatible with trimming due to reflection-based serialization
-.*Azure\.Core.src.JsonPatchDocument\.cs\(\d*\): Trim analysis warning IL2026: Azure\.JsonPatchDocument\.JsonPatchDocument\(ReadOnlyMemory`1<Byte>\): Using member 'Azure\.Core\.Serialization\.JsonObjectSerializer\.JsonObjectSerializer\(\)' which has 'RequiresUnreferencedCodeAttribute' can break functionality when trimming application code\. This class uses reflection-based JSON serialization and deserialization that is not compatible with trimming
-.*Azure\.Core.src.JsonPatchDocument\.cs\(\d*\): AOT analysis warning IL3050: Azure\.JsonPatchDocument\.JsonPatchDocument\(ReadOnlyMemory`1<Byte>\): Using member 'Azure\.Core\.Serialization\.JsonObjectSerializer\.JsonObjectSerializer\(\)' which has 'RequiresDynamicCodeAttribute' can break functionality when AOT compiling\. This class uses reflection-based JSON serialization and deserialization that is not compatible with trimming
-.*Azure\.Core.src.DynamicData.DynamicData\.AllowList\.cs\(\d*\): Trim analysis warning IL2070: Azure\.Core\.Serialization\.DynamicData\.AllowList\.IsAllowedAnonymousValue<T>\(Type,!!0\): 'this' argument does not satisfy 'DynamicallyAccessedMemberTypes\.PublicProperties' in call to 'System\.Type\.GetProperties\(\)'\. The parameter 'type' of method 'Azure\.Core\.Serialization\.DynamicData\.AllowList\.IsAllowedAnonymousValue<T>\(Type,!!0\)' does not have matching annotations\. The source value must declare at least the same requirements as those declared on the target location it is assigned to
 .*Azure\.Core.src.DynamicData.DynamicData\.ArrayEnumerator\.cs\(\d*\): Trim analysis warning IL2026: Azure\.Core\.Serialization\.DynamicData\.ArrayEnumerator\.Current\.get: Using member 'Azure\.Core\.Serialization\.DynamicData\.DynamicData\(MutableJsonElement,DynamicDataOptions\)' which has 'RequiresUnreferencedCodeAttribute' can break functionality when trimming application code\. This class utilizes reflection-based JSON serialization and deserialization which is not compatible with trimming
 .*Azure\.Core.src.DynamicData.DynamicData\.ArrayEnumerator\.cs\(\d*\): AOT analysis warning IL3050: Azure\.Core\.Serialization\.DynamicData\.ArrayEnumerator\.Current\.get: Using member 'Azure\.Core\.Serialization\.DynamicData\.DynamicData\(MutableJsonElement,DynamicDataOptions\)' which has 'RequiresDynamicCodeAttribute' can break functionality when AOT compiling\. This class utilizes reflection-based JSON serialization and deserialization which is not compatible with trimming
 .*Azure\.Core.src.DynamicData.DynamicData\.ObjectEnumerator\.cs\(\d*\): Trim analysis warning IL2026: Azure\.Core\.Serialization\.DynamicData\.ObjectEnumerator\.Current\.get: Using member 'Azure\.Core\.Serialization\.DynamicData\.DynamicData\(MutableJsonElement,DynamicDataOptions\)' which has 'RequiresUnreferencedCodeAttribute' can break functionality when trimming application code\. This class utilizes reflection-based JSON serialization and deserialization which is not compatible with trimming

Original file line number	Diff line number	Diff line change
`@@ -95,8 +95,10 @@ public HttpAuthorization(string scheme, string parameter) { }`
`95`	`95`	`}`
`96`	`96`	`public partial class JsonPatchDocument`
`97`	`97`	`{`
	`98`	`+ [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("JsonObjectSerializer uses reflection-based JSON serialization and deserialization that is not compatible with trimming.")]`
`98`	`99`	`public JsonPatchDocument() { }`
`99`	`100`	`public JsonPatchDocument(Azure.Core.Serialization.ObjectSerializer serializer) { }`
	`101`	`+ [System.Diagnostics.CodeAnalysis.RequiresUnreferencedCodeAttribute("JsonObjectSerializer uses reflection-based JSON serialization and deserialization that is not compatible with trimming.")]`
`100`	`102`	`public JsonPatchDocument(System.ReadOnlyMemory<byte> rawDocument) { }`
`101`	`103`	`public JsonPatchDocument(System.ReadOnlyMemory<byte> rawDocument, Azure.Core.Serialization.ObjectSerializer serializer) { }`
`102`	`104`	`public void AppendAddRaw(string path, string rawJsonValue) { }`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System;`
`5`	`5`	`using System.Collections;`
`6`	`6`	`using System.Collections.Generic;`
	`7`	`+using System.Diagnostics.CodeAnalysis;`
`7`	`8`	`using System.Reflection;`
`8`	`9`	`using System.Text.Json;`
`9`	`10`
`@@ -13,6 +14,7 @@ public partial class DynamicData`
`13`	`14`	`{`
`14`	`15`	`internal class AllowList`
`15`	`16`	`{`
	`17`	`+ [RequiresUnreferencedCode("Reflection over unknown type")]`
`16`	`18`	`public static void AssertAllowedValue<T>(T value)`
`17`	`19`	`{`
`18`	`20`	`if (value == null)`
`@@ -26,6 +28,7 @@ public static void AssertAllowedValue<T>(T value)`
`26`	`28`	`}`
`27`	`29`	`}`
`28`	`30`
	`31`	`+ [RequiresUnreferencedCode("Reflection over unknown type")]`
`29`	`32`	`private static bool IsAllowedValue<T>(T value)`
`30`	`33`	`{`
`31`	`34`	`if (value == null)`
`@@ -63,6 +66,7 @@ private static bool IsAllowedType(Type type)`
`63`	`66`	`type == typeof(DynamicData);`
`64`	`67`	`}`
`65`	`68`
	`69`	`+ [RequiresUnreferencedCode("Reflection over unknown type")]`
`66`	`70`	`private static bool IsAllowedCollectionValue<T>(Type type, T value)`
`67`	`71`	`{`
`68`	`72`	`return`
`@@ -71,6 +75,7 @@ private static bool IsAllowedCollectionValue<T>(Type type, T value)`
`71`	`75`	`IsAllowedDictionaryValue(type, value);`
`72`	`76`	`}`
`73`	`77`
	`78`	`+ [RequiresUnreferencedCode("Reflection over unknown type")]`
`74`	`79`	`private static bool IsAllowedArrayValue<T>(Type type, T value)`
`75`	`80`	`{`
`76`	`81`	`if (value is not Array array)`
`@@ -92,6 +97,7 @@ private static bool IsAllowedArrayValue<T>(Type type, T value)`
`92`	`97`	`return IsAllowedEnumerableValue(elementType, array);`
`93`	`98`	`}`
`94`	`99`
	`100`	`+ [RequiresUnreferencedCode("Reflection over unknown type")]`
`95`	`101`	`private static bool IsAllowedListValue<T>(Type type, T value)`
`96`	`102`	`{`
`97`	`103`	`if (value == null)`
`@@ -118,6 +124,7 @@ private static bool IsAllowedListValue<T>(Type type, T value)`
`118`	`124`	`return IsAllowedEnumerableValue(genericArgument, (IEnumerable)value);`
`119`	`125`	`}`
`120`	`126`
	`127`	`+ [RequiresUnreferencedCode("Reflection over unknown type")]`
`121`	`128`	`private static bool IsAllowedDictionaryValue<T>(Type type, T value)`
`122`	`129`	`{`
`123`	`130`	`if (value == null)`
`@@ -149,6 +156,7 @@ private static bool IsAllowedDictionaryValue<T>(Type type, T value)`
`149`	`156`	`return IsAllowedEnumerableValue(genericArguments[1], ((IDictionary)value).Values);`
`150`	`157`	`}`
`151`	`158`
	`159`	`+ [RequiresUnreferencedCode("Reflection over unknown type")]`
`152`	`160`	`private static bool IsAllowedEnumerableValue(Type elementType, IEnumerable enumerable)`
`153`	`161`	`{`
`154`	`162`	`foreach (var item in enumerable)`
`@@ -174,7 +182,8 @@ private static bool IsAllowedEnumerableValue(Type elementType, IEnumerable enume`
`174`	`182`	`return true;`
`175`	`183`	`}`
`176`	`184`
`177`		`- private static bool IsAllowedAnonymousValue<T>(Type type, T value)`
	`185`	`+ [RequiresUnreferencedCode("Reflection over unknown type")]`
	`186`	`+ private static bool IsAllowedAnonymousValue<T>([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties)] Type type, T value)`
`178`	`187`	`{`
`179`	`188`	`if (!IsAnonymousType(type))`
`180`	`189`	`{`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`
`4`	`4`	`using System;`
`5`	`5`	`using System.Collections.ObjectModel;`
	`6`	`+using System.Diagnostics.CodeAnalysis;`
`6`	`7`	`using System.IO;`
`7`	`8`	`using System.Linq;`
`8`	`9`	`using System.Text;`
`@@ -25,6 +26,8 @@ public class JsonPatchDocument`
`25`	`26`	`/// <summary>`
`26`	`27`	`/// Initializes a new instance of <see cref="JsonPatchDocument"/> that uses <see cref="JsonObjectSerializer"/> as the default serializer.`
`27`	`28`	`/// </summary>`
	`29`	`+ [RequiresUnreferencedCode("JsonObjectSerializer uses reflection-based JSON serialization and deserialization that is not compatible with trimming.")]`
	`30`	`+ [RequiresDynamicCode("JsonObjectSerializer uses reflection-based JSON serialization and deserialization that is not compatible with trimming.")]`
`28`	`31`	`public JsonPatchDocument() : this(default(ReadOnlyMemory<byte>))`
`29`	`32`	`{`
`30`	`33`	`}`
`@@ -41,6 +44,8 @@ public JsonPatchDocument(ObjectSerializer serializer): this(default(ReadOnlyMemo`
`41`	`44`	`/// Initializes a new instance of <see cref="JsonPatchDocument"/>`
`42`	`45`	`/// </summary>`
`43`	`46`	`/// <param name="rawDocument">The binary representation of JSON Patch document.</param>`
	`47`	`+ [RequiresUnreferencedCode("JsonObjectSerializer uses reflection-based JSON serialization and deserialization that is not compatible with trimming.")]`
	`48`	`+ [RequiresDynamicCode("JsonObjectSerializer uses reflection-based JSON serialization and deserialization that is not compatible with trimming.")]`
`44`	`49`	`public JsonPatchDocument(ReadOnlyMemory<byte> rawDocument) : this(rawDocument, new JsonObjectSerializer())`
`45`	`50`	`{`
`46`	`51`	`}`