chore: merge upstream

.github/workflows/build_pr.yml

@@ -4,6 +4,7 @@ on:
     pull_request:
         branches:
             - master
+            - v5-lts
 
 jobs:
     build:

.github/workflows/comment_pr.yml

@@ -40,9 +40,28 @@ jobs:
                         const {owner, repo} = context.repo;
                         const run_id = ${{github.event.workflow_run.id}};
 
-                        const pull_requests = ${{ toJSON(github.event.workflow_run.pull_requests) }};
+                        let pull_requests = ${{ toJSON(github.event.workflow_run.pull_requests) }};
+
+                        if (!pull_requests.length) {
+                          core.info("No PRs in workflow_run payload; resolving by branch head");
+                          const headBranch = context.payload.workflow_run.head_branch;
+
+                          // Search open PRs in base repo and match by branch name (works for many fork cases)
+                          const { data } = await github.rest.pulls.list({
+                            owner,
+                            repo,
+                            state: "open",
+                            per_page: 100,
+                          });
+
+                          pull_requests = data.filter(pr => {
+                            // pr.head.ref is branch name; for forks also check same branch name
+                            return pr.head.ref === headBranch;
+                          });
+                        }
+
                         if (!pull_requests.length) {
-                          return core.error("This workflow doesn't match any pull requests!");
+                          return core.error("Could not resolve pull request for this workflow run.");
                         }
 
                         const artifacts = await github.paginate(

BepInEx.Core/Bootstrap/BaseChainloader.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -12,10 +12,10 @@
 
 namespace BepInEx.Bootstrap;
 
 public abstract class BaseChainloader<TPlugin>
 {
     protected static readonly string CurrentAssemblyName = Assembly.GetExecutingAssembly().GetName().Name;
     protected static readonly Version CurrentAssemblyVersion = Assembly.GetExecutingAssembly().GetName().Version;
     private static readonly Dictionary<string, bool> RefCache = new();
     private static Regex allowedGuidRegex { get; } = new(@"^[a-zA-Z0-9\._\-]+$");
 
@@ -107,7 +107,7 @@
         }
         return RefCache[key] = false;
     }
     protected static bool HasBepinPlugins(AssemblyDefinition ass)
     {
         if (!ReferencesThisAssembly(ass))
             return false;
@@ -370,7 +370,15 @@
             var plugins = DiscoverPlugins();
             Logger.Log(LogLevel.Info, $"{plugins.Count} plugin{(plugins.Count == 1 ? "" : "s")} to load");
             LoadPlugins(plugins);
-            Finished?.Invoke();
+
+            try
+            {
+                Finished?.Invoke();
+            }
+            catch (Exception ex)
+            {
+                Logger.Log(LogLevel.Error, $"Error occurred in a Chainloader.Finished event handler: {ex}");
+            }
         }
         catch (Exception ex)
         {
@@ -399,6 +407,7 @@
         {
             var dependsOnInvalidPlugin = false;
             var missingDependencies = new List<BepInDependency>();
+            var incompatibleDependencies = new List<KeyValuePair<BepInDependency, string>>();
             foreach (var dependency in plugin.Dependencies)
             {
                 static bool IsHardDependency(BepInDependency dep) =>
@@ -414,15 +423,22 @@
                     pluginVersion = pluginInfo?.Metadata.Version;
                 }
 
-                if (!dependencyExists || dependency.VersionRange != null &&
-                    !dependency.VersionRange.IsSatisfied(pluginVersion))
+                // The dependency is not installed at all.
+                if (!dependencyExists)
                 {
-                    // If the dependency is hard, collect it into a list to show
                     if (IsHardDependency(dependency))
                         missingDependencies.Add(dependency);
                     continue;
                 }
 
+                // The dependency is installed, but its version does not satisfy the requested range.
+                if (dependency.VersionRange != null && !dependency.VersionRange.IsSatisfied(pluginVersion))
+                {
+                    if (IsHardDependency(dependency))
+                        incompatibleDependencies.Add(new KeyValuePair<BepInDependency, string>(dependency, pluginVersion?.ToString()));
+                    continue;
+                }
+
                 // If the dependency is a hard and is invalid (e.g. has missing dependencies), report that to the user
                 if (invalidPlugins.Contains(dependency.DependencyGUID) && IsHardDependency(dependency))
                 {
@@ -442,13 +458,25 @@
                 continue;
             }
 
-            if (missingDependencies.Count != 0)
+            if (missingDependencies.Count != 0 || incompatibleDependencies.Count != 0)
             {
-                var message = $@"Could not load [{plugin}] because it has missing dependencies: {
-                    string.Join(", ", missingDependencies.Select(s => s.VersionRange == null ? s.DependencyGUID : $"{s.DependencyGUID} ({s.VersionRange})").ToArray())
-                }";
-                DependencyErrors.Add(message);
-                Logger.Log(LogLevel.Error, message);
+                if (missingDependencies.Count != 0)
+                {
+                    var message = $@"Could not load [{plugin}] because it has missing dependencies: {
+                        string.Join(", ", missingDependencies.Select(s => s.VersionRange == null ? s.DependencyGUID : $"{s.DependencyGUID} ({s.VersionRange})").ToArray())
+                    }. Install the listed plugin(s) and restart the game.";
+                    DependencyErrors.Add(message);
+                    Logger.Log(LogLevel.Error, message);
+                }
+
+                if (incompatibleDependencies.Count != 0)
+                {
+                    var message = $@"Could not load [{plugin}] because the following dependencies are installed with an incompatible version: {
+                        string.Join(", ", incompatibleDependencies.Select(s => $"{s.Key.DependencyGUID} (found {s.Value}, requires {s.Key.VersionRange})").ToArray())
+                    }. Update the listed plugin(s) to a version that satisfies the requirement.";
+                    DependencyErrors.Add(message);
+                    Logger.Log(LogLevel.Error, message);
+                }
 
                 invalidPlugins.Add(plugin.Metadata.GUID);
                 continue;

BepInEx.Core/Configuration/ConfigFile.cs

@@ -34,7 +34,7 @@ public ConfigFile(string configPath, bool saveOnInit, BepInPlugin ownerMetadata)
 
         if (File.Exists(ConfigFilePath))
             Reload();
-        else if (saveOnInit) Save();
+        else if (saveOnInit) TrySave();
     }
 
     public static ConfigFile CoreConfig { get; } = new(Paths.BepInExConfigPath, true);
@@ -92,9 +92,12 @@ public ConfigEntryBase this[ConfigDefinition key]
     public ConfigEntryBase this[string section, string key] => this[new ConfigDefinition(section, key)];
 
     /// <inheritdoc />
-    public IEnumerator<KeyValuePair<ConfigDefinition, ConfigEntryBase>> GetEnumerator() =>
-        // We can't really do a read lock for this
-        Entries.GetEnumerator();
+    public IEnumerator<KeyValuePair<ConfigDefinition, ConfigEntryBase>> GetEnumerator()
+    {
+        // Enumerate a snapshot taken under the lock so a concurrent mutation cannot invalidate the iterator.
+        lock (_ioLock)
+            return Entries.ToList().GetEnumerator();
+    }
 
     IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
@@ -352,6 +355,24 @@ public void Save()
         }
     }
 
+    /// <summary>
+    ///     Writes the config to disk like <see cref="Save" />, but logs and swallows I/O failures (e.g. a read-only
+    ///     or locked config file) instead of throwing. Used only for the creation-time saves (initial file write and
+    ///     new-entry binds), which can run before logging is up; explicit saves and setting changes still throw.
+    /// </summary>
+    private void TrySave()
+    {
+        try
+        {
+            Save();
+        }
+        catch (Exception e) when (e is IOException or UnauthorizedAccessException)
+        {
+            Logger.Log(LogLevel.Warning,
+                $"Could not write config file {ConfigFilePath}: {e.Message}. Continuing with the in-memory configuration.");
+        }
+    }
+
     #endregion
 
     #region Wraps
@@ -452,7 +473,7 @@ public ConfigEntry<T> Bind<T>(ConfigDefinition configDefinition,
             }
 
             if (SaveOnConfigSet)
-                Save();
+                TrySave();
 
             return entry;
         }

BepInEx.Core/Configuration/TomlTypeConverter.cs

@@ -31,11 +31,6 @@ public static class TomlTypeConverter
             ConvertToString = (obj, type) => obj.ToString().ToLowerInvariant(),
             ConvertToObject = (str, type) => bool.Parse(str)
         },
-        [typeof(byte)] = new TypeConverter
-        {
-            ConvertToString = (obj, type) => obj.ToString(),
-            ConvertToObject = (str, type) => byte.Parse(str)
-        },
 
         //integral types
 

BepInEx.Core/Console/Unix/ConsoleWriter.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.IO;
 using System.Linq;
 using System.Reflection;

BepInEx.Core/Console/Unix/TtyHandler.cs

@@ -1,4 +1,4 @@
-// Sections of this code have been abridged from https://github.com/mono/mono/blob/master/mcs/class/corlib/System/TermInfoReader.cs under the MIT license
+// Sections of this code have been abridged from https://github.com/mono/mono/blob/master/mcs/class/corlib/System/TermInfoReader.cs under the MIT license
 
 using System;
 using System.IO;

BepInEx.Core/Console/Unix/UnixStream.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.IO;
 using System.Runtime.InteropServices;
 

BepInEx.Core/Console/Unix/UnixStreamHelper.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.IO;
 using System.Runtime.InteropServices;
 using BepInEx.Core;

BepInEx.Core/Console/Windows/ConsoleEncoding/ConsoleEncoding.cs

@@ -41,7 +41,7 @@ public static uint ConsoleCodePage
     public override int GetByteCount(char[] chars, int index, int count)
     {
         WriteCharBuffer(chars, index, count);
-        var result = WideCharToMultiByte(_codePage, 0, chars, count, _zeroByte, 0, IntPtr.Zero, IntPtr.Zero);
+        var result = WideCharToMultiByte(_codePage, 0, _charBuffer, count, _zeroByte, 0, IntPtr.Zero, IntPtr.Zero);
         return result;
     }
 
@@ -50,7 +50,7 @@ public override int GetBytes(char[] chars, int charIndex, int charCount, byte[]
         var byteCount = GetByteCount(chars, charIndex, charCount);
         WriteCharBuffer(chars, charIndex, charCount);
         ExpandByteBuffer(byteCount);
-        _ = WideCharToMultiByte(_codePage, 0, chars, charCount, _byteBuffer, byteCount, IntPtr.Zero,
+        _ = WideCharToMultiByte(_codePage, 0, _charBuffer, charCount, _byteBuffer, byteCount, IntPtr.Zero,
                                 IntPtr.Zero);
         var readCount = Math.Min(bytes.Length, byteCount);
         ReadByteBuffer(bytes, byteIndex, readCount);
@@ -60,7 +60,7 @@ public override int GetBytes(char[] chars, int charIndex, int charCount, byte[]
     public override int GetCharCount(byte[] bytes, int index, int count)
     {
         WriteByteBuffer(bytes, index, count);
-        var result = MultiByteToWideChar(_codePage, 0, bytes, count, _zeroChar, 0);
+        var result = MultiByteToWideChar(_codePage, 0, _byteBuffer, count, _zeroChar, 0);
         return result;
     }
 
@@ -69,7 +69,7 @@ public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[]
         var charCount = GetCharCount(bytes, byteIndex, byteCount);
         WriteByteBuffer(bytes, byteIndex, byteCount);
         ExpandCharBuffer(charCount);
-        _ = MultiByteToWideChar(_codePage, 0, bytes, byteCount, _charBuffer, charCount);
+        _ = MultiByteToWideChar(_codePage, 0, _byteBuffer, byteCount, _charBuffer, charCount);
         var readCount = Math.Min(chars.Length, charCount);
         ReadCharBuffer(chars, charIndex, readCount);
         return readCount;

BepInEx.Core/Console/Windows/ConsoleWindow.cs

@@ -1,4 +1,4 @@
-// --------------------------------------------------
+// --------------------------------------------------
 // UnityInjector - ConsoleWindow.cs
 // Copyright (c) Usagirei 2015 - 2015
 // --------------------------------------------------

BepInEx.Core/Console/Windows/WindowsConsoleDriver.cs

@@ -94,8 +94,9 @@ public void CreateConsole(uint codepage)
         // Make sure of ConsoleEncoding helper class because on some Monos
         // Encoding.GetEncoding throws NotImplementedException on most codepages
         // NOTE: We don't set Console.OutputEncoding because it resets any existing Console.Out writers
-        if (!useManagedEncoder)
-            ConsoleEncoding.ConsoleCodePage = codepage;
+        // Always set the console output codepage so the Windows console interprets bytes correctly,
+        // regardless of whether we use a managed encoder or ConsoleEncoding to produce those bytes.
+        ConsoleEncoding.ConsoleCodePage = codepage;
 
         // If stdout exists, write to it, otherwise make it the same as console out
         // Not sure if this is needed? Does the original Console.Out still work?
@@ -161,7 +162,7 @@ private static Stream OpenFileStream(IntPtr handle)
         {
             var windowsConsoleStreamType = Type.GetType("System.ConsolePal+WindowsConsoleStream, System.Console", true);
             var constructor = AccessTools.Constructor(windowsConsoleStreamType,
-                                                        new[] { typeof(IntPtr), typeof(FileAccess), typeof(bool) });
+                                                      new[] { typeof(IntPtr), typeof(FileAccess), typeof(bool) });
             return (Stream)constructor.Invoke(new object[] { handle, FileAccess.Write, true });
         }
 
@@ -191,3 +192,4 @@ private IntPtr GetOutHandle()
         }
     }
 }
+

BepInEx.Core/Contract/Attributes.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -120,8 +120,18 @@ public BepInDependency(string DependencyGUID, DependencyFlags Flags = Dependency
     ///     not load and an error will be logged instead.
     /// </summary>
     /// <param name="guid">The GUID of the referenced plugin.</param>
-    /// <param name="version">The version range of the referenced plugin.</param>
-    /// <remarks>When version is supplied the dependency is always treated as HardDependency</remarks>
+    /// <param name="version">
+    ///     The version requirement of the referenced plugin, parsed as a SemVer range
+    ///     (see <see href="https://github.com/adamreeve/semver.net#ranges" />). A plain version such as
+    ///     <c>1.2.0</c> requires that exact version; use a range such as <c>&gt;=1.2.0</c>, <c>1.2.*</c>,
+    ///     <c>~1.2.0</c> or <c>^1.2.0</c> to accept more than one version.
+    /// </param>
+    /// <remarks>
+    ///     When a version is supplied the dependency is always treated as a hard dependency.
+    ///     Plugins migrating from BepInEx 5 should note a behaviour change: a bare version was previously
+    ///     treated as a minimum (<c>&gt;=</c>), whereas in BepInEx 6 it is an exact match. Use
+    ///     <c>&gt;=1.2.0</c> to keep the old behaviour.
+    /// </remarks>
     public BepInDependency(string guid, string version) : this(guid)
     {
         VersionRange = Range.Parse(version);
@@ -266,7 +276,7 @@ internal static IEnumerable<CustomAttribute> GetCustomAttributes<T>(TypeDefiniti
         var currentType = td;
 
         do
-        {           
+        {
             result.AddRange(currentType.CustomAttributes.Where(inheritAttribute ? (ca => TypeInheretsFrom(ca.AttributeType, type)) : (ca => ca.AttributeType.FullName == type.FullName)));
             currentType = currentType.BaseType?.Resolve();
         } while (inheritType && currentType?.FullName != "System.Object");
@@ -343,3 +353,4 @@ public static IEnumerable<BepInDependency> GetDependencies(Type plugin) =>
 }
 
 #endregion
+

BepInEx.Core/PlatformUtils.cs

@@ -97,7 +97,7 @@ internal static class PlatformUtils
     public static Platform Current { get; private set; }
 
     public static bool Is(Platform expected) => (Current & expected) == expected;
-    public static bool Is(this Platform current, Platform expected) => (current & expected) == expected;
+    private static bool Is(this Platform current, Platform expected) => (current & expected) == expected;
 
 
     public static T AsDelegate<T>(this IntPtr procAddress) where T : Delegate
@@ -140,9 +140,9 @@ public static void SetPlatform()
             var windowsVersionInfo = new WindowsOSVersionInfoExW();
             RtlGetVersion(ref windowsVersionInfo);
 
-            WindowsVersion = new Version((int)windowsVersionInfo.dwMajorVersion,
-                                         (int)windowsVersionInfo.dwMinorVersion, 0,
-                                         (int)windowsVersionInfo.dwBuildNumber);
+            WindowsVersion = new Version((int) windowsVersionInfo.dwMajorVersion,
+                                         (int) windowsVersionInfo.dwMinorVersion, 0,
+                                         (int) windowsVersionInfo.dwBuildNumber);
 
             var ntDll = LoadLibrary("ntdll.dll");
             if (ntDll != IntPtr.Zero)
@@ -151,7 +151,12 @@ public static void SetPlatform()
                 if (wineGetVersion != IntPtr.Zero)
                 {
                     current |= Platform.Wine;
-                    var getVersion = wineGetVersion.AsDelegate<GetWineVersionDelegate>();
+                    // It's not safe to use the AsDelegate() extension method here because:
+                    //  - It comes from the MonoMod.Utils.DynDll class, defined in MonoMod.Common.
+                    //  - The DynDll class has a static constructor that reads PlatformHelper.Current.
+                    //  - Reading from that property freezes it: subsequent writes will throw an exception.
+                    //  - This method only sets PlatformHelper.Current at the very end.
+                    var getVersion = Marshal.GetDelegateForFunctionPointer(wineGetVersion, typeof(GetWineVersionDelegate)) as GetWineVersionDelegate;
                     WineVersion = getVersion();
                 }
             }