[dotnet] Annotate CDP as AOT-unsafe

dotnet/src/webdriver/DevTools/DevToolsDomains.cs

@@ -19,6 +19,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 
 namespace OpenQA.Selenium.DevTools
@@ -35,14 +36,22 @@ public abstract class DevToolsDomains
         // This is the list of known supported DevTools version implementation.
         // When new versions are implemented for support, new types must be
         // added to this dictionary.
-        private static readonly Dictionary<int, Type> SupportedDevToolsVersions = new Dictionary<int, Type>()
+        private static readonly Dictionary<int, DomainType> SupportedDevToolsVersions = new Dictionary<int, DomainType>()
         {
-            { 130, typeof(V130.V130Domains) },
-            { 129, typeof(V129.V129Domains) },
-            { 128, typeof(V128.V128Domains) },
-            { 85, typeof(V85.V85Domains) }
+            { 130, new DomainType(typeof(V130.V130Domains)) },
+            { 129, new DomainType(typeof(V129.V129Domains)) },
+            { 128, new DomainType(typeof(V128.V128Domains)) },
+            { 85, new DomainType(typeof(V85.V85Domains)) }
         };
 
+        /// <summary>Workaround for trimming.</summary>
+        private readonly struct DomainType
+        {
+            [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)]
+            public readonly Type Type;
+
+            public DomainType([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type t) => Type = t;
+        }
         /// <summary>
         /// Gets the version-specific domains for the DevTools session. This value must be cast to a version specific type to be at all useful.
         /// </summary>
@@ -104,12 +113,13 @@ public static DevToolsDomains InitializeDomains(int protocolVersion, DevToolsSes
             return domains;
         }
 
+        [return: DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)]
         private static Type MatchDomainsVersion(int desiredVersion, int versionRange)
         {
             // Return fast on an exact match
-            if (SupportedDevToolsVersions.ContainsKey(desiredVersion))
+            if (SupportedDevToolsVersions.TryGetValue(desiredVersion, out DomainType type))
             {
-                return SupportedDevToolsVersions[desiredVersion];
+                return type.Type;
             }
 
             // Get the list of supported versions and sort descending
@@ -123,7 +133,7 @@ private static Type MatchDomainsVersion(int desiredVersion, int versionRange)
                 // (that is, closest without going over).
                 if (desiredVersion >= supportedVersion && desiredVersion - supportedVersion < versionRange)
                 {
-                    return SupportedDevToolsVersions[supportedVersion];
+                    return SupportedDevToolsVersions[supportedVersion].Type;
                 }
             }
 

dotnet/src/webdriver/DevTools/Json/JsonEnumMemberConverter.cs

@@ -19,26 +19,31 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Runtime.Serialization;
 using System.Text.Json;
 using System.Text.Json.Serialization;
 
 namespace OpenQA.Selenium.DevTools.Json
 {
-    internal class JsonEnumMemberConverter<TEnum> : JsonConverter<TEnum> where TEnum : Enum
+    internal class JsonEnumMemberConverter<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicFields)] TEnum>
+        : JsonConverter<TEnum> where TEnum : struct, Enum
     {
         private readonly Dictionary<TEnum, string> _enumToString = new Dictionary<TEnum, string>();
         private readonly Dictionary<string, TEnum> _stringToEnum = new Dictionary<string, TEnum>();
 
         public JsonEnumMemberConverter()
         {
             var type = typeof(TEnum);
-            var values = Enum.GetValues(type);
-
+#if NET8_0_OR_GREATER
+            TEnum[] values = Enum.GetValues<TEnum>();
+#else
+            Array values = Enum.GetValues(type);
+#endif
             foreach (var value in values)
             {
-                var enumMember = type.GetMember(value.ToString())[0];
+                var enumMember = type.GetField(value.ToString());
                 var attr = enumMember.GetCustomAttributes(typeof(EnumMemberAttribute), false)
                   .Cast<EnumMemberAttribute>()
                   .FirstOrDefault();

dotnet/src/webdriver/Internal/FileUtilities.cs

@@ -186,12 +186,14 @@ public static string GetCurrentDirectory()
 
             string currentDirectory = location;
 
+#if !NET8_0_OR_GREATER
             // If we're shadow copying, get the directory from the codebase instead
             if (AppDomain.CurrentDomain.ShadowCopyFiles)
             {
                 Uri uri = new Uri(executingAssembly.CodeBase);
                 currentDirectory = Path.GetDirectoryName(uri.LocalPath);
             }
+#endif
 
             return currentDirectory;
         }