Version: 239.0.6

Apparently NetSerializer treats IDynamicTypeSerializer and IStaticTypeSerializer differently for sealed types??

(cherry-picked from 6bbeaeeba6, without the test changes)

(cherry picked from commit d187018834dfa1cdead9ce5a7b72c38b07f8c81f)

Directory.Packages.props

@@ -57,12 +57,12 @@
     <PackageVersion Include="SharpZstd.Interop" Version="1.5.2-beta2" />
     <PackageVersion Include="SixLabors.ImageSharp" Version="3.1.6" />
     <PackageVersion Include="SpaceWizards.HttpListener" Version="0.1.1" />
-    <PackageVersion Include="SpaceWizards.NFluidsynth" Version="0.1.1" />
+    <PackageVersion Include="SpaceWizards.NFluidsynth" Version="0.2.2" />
     <PackageVersion Include="SpaceWizards.SharpFont" Version="1.0.2" />
     <PackageVersion Include="SpaceWizards.Sodium" Version="0.2.1" />
     <PackageVersion Include="TerraFX.Interop.Windows" Version="10.0.26100.1" />
     <PackageVersion Include="TerraFX.Interop.Xlib" Version="6.4.0" />
-    <PackageVersion Include="VorbisPizza" Version="1.4.2" />
+    <PackageVersion Include="VorbisPizza" Version="1.3.0" />
     <PackageVersion Include="YamlDotNet" Version="16.3.0" />
     <PackageVersion Include="prometheus-net" Version="8.2.1" />
     <PackageVersion Include="prometheus-net.DotNetRuntime" Version="4.4.0" />

MSBuild/Robust.Engine.Version.props

@@ -1,4 +1,4 @@
 <Project>
 
-    <!-- This file automatically reset by Tools/version.py -->
+    <!-- This file automatically reset by Tools/version.py -->
 

RELEASE-NOTES.md

@@ -54,6 +54,33 @@ END TEMPLATE-->
 *None yet*
 
 
+## 239.0.6
+
+
+## 239.0.5
+
+
+## 239.0.4
+
+
+## 239.0.3
+
+
+## 239.0.2
+
+
+## 239.0.1
+
+### Bugfixes
+
+* Fix logging of received packets with `net.packet` logging level.
+* Downgrade `VorbisPizza` to fix audio playback for systems without AVX2 support.
+
+### Other
+
+* Improved performance of some Roslyn analyzers and source generators, which should significantly improve compile times and IDE performance.
+
+
 ## 239.0.0
 
 ### Breaking changes

Robust.Analyzers.Tests/ByRefEventAnalyzerTest.cs

@@ -0,0 +1,114 @@
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CSharp.Testing;
+using Microsoft.CodeAnalysis.Testing;
+using NUnit.Framework;
+using VerifyCS =
+    Microsoft.CodeAnalysis.CSharp.Testing.CSharpAnalyzerVerifier<Robust.Analyzers.ByRefEventAnalyzer, Microsoft.CodeAnalysis.Testing.DefaultVerifier>;
+
+namespace Robust.Analyzers.Tests;
+
+[Parallelizable(ParallelScope.All | ParallelScope.Fixtures)]
+[TestFixture, TestOf(typeof(ByRefEventAnalyzer))]
+public sealed class ByRefEventAnalyzerTest
+{
+    private const string EventBusDef = """
+        namespace Robust.Shared.GameObjects;
+
+        public readonly struct EntityUid;
+
+        public sealed class EntitySystem
+        {
+            public void RaiseLocalEvent<TEvent>(EntityUid uid, ref TEvent args, bool broadcast = false)
+                where TEvent : notnull { }
+
+            public void RaiseLocalEvent<TEvent>(EntityUid uid, TEvent args, bool broadcast = false)
+                where TEvent : notnull { }
+        }
+
+        public sealed class EntityEventBus
+        {
+            public void RaiseLocalEvent<TEvent>(EntityUid uid, ref TEvent args, bool broadcast = false)
+                where TEvent : notnull { }
+
+            public void RaiseLocalEvent<TEvent>(EntityUid uid, TEvent args, bool broadcast = false)
+                where TEvent : notnull { }
+        }
+        """;
+
+    private static Task Verifier(string code, params DiagnosticResult[] expected)
+    {
+        var test = new CSharpAnalyzerTest<ByRefEventAnalyzer, DefaultVerifier>()
+        {
+            TestState =
+            {
+                Sources = { code }
+            },
+        };
+
+        TestHelper.AddEmbeddedSources(
+            test.TestState,
+            "Robust.Shared.GameObjects.EventBusAttributes.cs"
+        );
+
+        test.TestState.Sources.Add(("EntityEventBus.cs", EventBusDef));
+
+        // ExpectedDiagnostics cannot be set, so we need to AddRange here...
+        test.TestState.ExpectedDiagnostics.AddRange(expected);
+
+        return test.RunAsync();
+    }
+
+    [Test]
+    public async Task TestSuccess()
+    {
+        const string code = """
+            using Robust.Shared.GameObjects;
+
+            [ByRefEvent]
+            public readonly struct RefEvent;
+            public readonly struct ValueEvent;
+
+            public static class Foo
+            {
+                public static void Bar(EntityEventBus bus)
+                {
+                    bus.RaiseLocalEvent(default(EntityUid), new ValueEvent());
+                    var refEv = new RefEvent();
+                    bus.RaiseLocalEvent(default(EntityUid), ref refEv);
+                }
+            }
+            """;
+
+        await Verifier(code);
+    }
+
+    [Test]
+    public async Task TestWrong()
+    {
+        const string code = """
+            using Robust.Shared.GameObjects;
+
+            [ByRefEvent]
+            public readonly struct RefEvent;
+            public readonly struct ValueEvent;
+
+            public static class Foo
+            {
+                public static void Bar(EntityEventBus bus)
+                {
+                    bus.RaiseLocalEvent(default(EntityUid), new RefEvent());
+                    var valueEv = new ValueEvent();
+                    bus.RaiseLocalEvent(default(EntityUid), ref valueEv);
+                }
+            }
+            """;
+
+        await Verifier(
+            code,
+            // /0/Test0.cs(11,49): error RA0015: Tried to raise a by-ref event 'RefEvent' by value
+            VerifyCS.Diagnostic(ByRefEventAnalyzer.ByRefEventRaisedByValueRule).WithSpan(11, 49, 11, 63).WithArguments("RefEvent"),
+            // /0/Test0.cs(13,49): error RA0016: Tried to raise a value event 'ValueEvent' by-ref
+            VerifyCS.Diagnostic(ByRefEventAnalyzer.ByValueEventRaisedByRefRule).WithSpan(13, 49, 13, 60).WithArguments("ValueEvent")
+        );
+    }
+}

Robust.Analyzers.Tests/Robust.Analyzers.Tests.csproj

@@ -14,6 +14,7 @@
     <EmbeddedResource Include="..\Robust.Shared\Analyzers\PreferNonGenericVariantForAttribute.cs" LogicalName="Robust.Shared.Analyzers.PreferNonGenericVariantForAttribute.cs" LinkBase="Implementations" />
     <EmbeddedResource Include="..\Robust.Shared\Analyzers\PreferOtherTypeAttribute.cs" LogicalName="Robust.Shared.Analyzers.PreferOtherTypeAttribute.cs" LinkBase="Implementations" />
     <EmbeddedResource Include="..\Robust.Shared\IoC\DependencyAttribute.cs" LogicalName="Robust.Shared.IoC.DependencyAttribute.cs" LinkBase="Implementations" />
+    <EmbeddedResource Include="..\Robust.Shared\GameObjects\EventBusAttributes.cs" LogicalName="Robust.Shared.GameObjects.EventBusAttributes.cs" LinkBase="Implementations" />
   </ItemGroup>
 
   <PropertyGroup>

Robust.Analyzers/ByRefEventAnalyzer.cs

@@ -1,4 +1,4 @@
-#nullable enable
+#nullable enable
 using System.Collections.Immutable;
 using System.Linq;
 using Microsoft.CodeAnalysis;
@@ -24,7 +24,7 @@ public sealed class ByRefEventAnalyzer : DiagnosticAnalyzer
         "Make sure that methods subscribing to a ref event have the ref keyword for the event argument."
     );
 
-    private static readonly DiagnosticDescriptor ByRefEventRaisedByValueRule = new(
+    public static readonly DiagnosticDescriptor ByRefEventRaisedByValueRule = new(
         Diagnostics.IdByRefEventRaisedByValue,
         "By-ref event raised by value",
         "Tried to raise a by-ref event '{0}' by value",
@@ -34,7 +34,7 @@ public sealed class ByRefEventAnalyzer : DiagnosticAnalyzer
         "Make sure to use the ref keyword when raising ref events."
     );
 
-    private static readonly DiagnosticDescriptor ByValueEventRaisedByRefRule = new(
+    public static readonly DiagnosticDescriptor ByValueEventRaisedByRefRule = new(
         Diagnostics.IdValueEventRaisedByRef,
         "Value event raised by-ref",
         "Tried to raise a value event '{0}' by-ref",
@@ -54,32 +54,44 @@ public sealed class ByRefEventAnalyzer : DiagnosticAnalyzer
     {
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics);
         context.EnableConcurrentExecution();
-        context.RegisterOperationAction(CheckEventRaise, OperationKind.Invocation);
+        context.RegisterCompilationStartAction(compilationContext =>
+        {
+            var raiseMethods = compilationContext.Compilation
+                .GetTypeByMetadataName("Robust.Shared.GameObjects.EntitySystem")?
+                .GetMembers()
+                .Where(m => m.Name.Contains("RaiseLocalEvent") && m.Kind == SymbolKind.Method)
+                .Cast<IMethodSymbol>();
+
+            var busRaiseMethods = compilationContext.Compilation
+                .GetTypeByMetadataName("Robust.Shared.GameObjects.EntityEventBus")?
+                .GetMembers()
+                .Where(m => m.Name.Contains("RaiseLocalEvent") && m.Kind == SymbolKind.Method)
+                .Cast<IMethodSymbol>();
+
+            if (raiseMethods == null)
+                return;
+
+            if (busRaiseMethods != null)
+                raiseMethods = raiseMethods.Concat(busRaiseMethods);
+
+            var raiseMethodsArray = raiseMethods.ToArray();
+
+            compilationContext.RegisterOperationAction(
+                ctx => CheckEventRaise(ctx, raiseMethodsArray),
+                OperationKind.Invocation);
+        });
     }
 
-    private void CheckEventRaise(OperationAnalysisContext context)
+    private static void CheckEventRaise(
+        OperationAnalysisContext context,
+        IReadOnlyCollection<IMethodSymbol> raiseMethods)
     {
         if (context.Operation is not IInvocationOperation operation)
             return;
 
-        var raiseMethods = context.Compilation
-            .GetTypeByMetadataName("Robust.Shared.GameObjects.EntitySystem")?
-            .GetMembers()
-            .Where(m => m.Name.Contains("RaiseLocalEvent") && m.Kind == SymbolKind.Method)
-            .Cast<IMethodSymbol>();
-
-        var busRaiseMethods = context.Compilation
-            .GetTypeByMetadataName("Robust.Shared.GameObjects.EntityEventBus")?
-            .GetMembers()
-            .Where(m => m.Name.Contains("RaiseLocalEvent") && m.Kind == SymbolKind.Method)
-            .Cast<IMethodSymbol>();
-
-        if (raiseMethods == null)
+        if (!operation.TargetMethod.Name.Contains("RaiseLocalEvent"))
             return;
 
-        if (busRaiseMethods != null)
-            raiseMethods = raiseMethods.Concat(busRaiseMethods);
-
         if (!raiseMethods.Any(m => m.Equals(operation.TargetMethod.OriginalDefinition, Default)))
         {
             // If you try to do this normally by concatenating like busRaiseMethods above

Robust.Client.WebView/Cef/Program.cs

@@ -6,7 +6,7 @@ using Xilium.CefGlue;
 
 namespace Robust.Client.WebView.Cef
 {
-    public static class Program
+    internal static class Program
     {
         // This was supposed to be the main entry for the subprocess program... It doesn't work.
         public static int Main(string[] args)

Robust.Client.WebView/Cef/WebViewManagerCef.cs

@@ -5,6 +5,7 @@ using System.Net;
 using System.Reflection;
 using System.Text;
 using Robust.Client.Console;
+using Robust.Client.Utility;
 using Robust.Shared.Configuration;
 using Robust.Shared.ContentPack;
 using Robust.Shared.IoC;
@@ -24,6 +25,7 @@ namespace Robust.Client.WebView.Cef
 
         [Dependency] private readonly IDependencyCollection _dependencyCollection = default!;
         [Dependency] private readonly IPrototypeManager _prototypeManager = default!;
+        [Dependency] private readonly IGameControllerInternal _gameController = default!;
         [Dependency] private readonly IResourceManagerInternal _resourceManager = default!;
         [Dependency] private readonly IClientConsoleHost _consoleHost = default!;
         [Dependency] private readonly IConfigurationManager _cfg = default!;
@@ -61,7 +63,10 @@ namespace Robust.Client.WebView.Cef
 
             var cachePath = "";
             if (_resourceManager.UserData is WritableDirProvider userData)
-                cachePath = userData.GetFullPath(new ResPath("/cef_cache"));
+            {
+                var rootDir = UserDataDir.GetRootUserDataDir(_gameController);
+                cachePath = Path.Combine(rootDir, "cef_cache", "0");
+            }
 
             var settings = new CefSettings()
             {

Robust.Client/GameController/GameController.cs

@@ -382,7 +382,7 @@ namespace Robust.Client
 
             _prof.Initialize();
 
-            _resManager.Initialize(Options.LoadConfigAndUserData ? userDataDir : null);
+            _resManager.Initialize(Options.LoadConfigAndUserData ? userDataDir : null, hideUserDataDir: true);
 
             var mountOptions = _commandLineArgs != null
                 ? MountOptions.Merge(_commandLineArgs.MountOptions, Options.MountOptions)

Robust.Serialization.Generator/Generator.cs

@@ -19,117 +19,112 @@ public class Generator : IIncrementalGenerator
 
     public void Initialize(IncrementalGeneratorInitializationContext initContext)
     {
-        IncrementalValuesProvider<TypeDeclarationSyntax> dataDefinitions = initContext.SyntaxProvider.CreateSyntaxProvider(
-            static (node, _) => node is TypeDeclarationSyntax,
-            static (context, _) =>
-            {
-                var type = (TypeDeclarationSyntax) context.Node;
-                var symbol = (ITypeSymbol) context.SemanticModel.GetDeclaredSymbol(type)!;
-                return IsDataDefinition(symbol) ? type : null;
-            }
-        ).Where(static type => type != null)!;
+        IncrementalValuesProvider<(string name, string code)?> dataDefinitions = initContext.SyntaxProvider
+            .CreateSyntaxProvider(
+                static (node, _) => node is TypeDeclarationSyntax,
+                static (context, _) =>
+                {
+                    var type = (TypeDeclarationSyntax)context.Node;
+                    var symbol = (ITypeSymbol)context.SemanticModel.GetDeclaredSymbol(type)!;
+                    if (!IsDataDefinition(symbol))
+                        return null;
+
+                    return GenerateForDataDefinition(type, symbol);
+                }
+            )
+            .Where(static type => type != null);
 
-        var comparer = new DataDefinitionComparer();
         initContext.RegisterSourceOutput(
-            initContext.CompilationProvider.Combine(dataDefinitions.WithComparer(comparer).Collect()),
+            dataDefinitions,
             static (sourceContext, source) =>
             {
-                var (compilation, declarations) = source;
-                var builder = new StringBuilder();
-                var containingTypes = new Stack<INamedTypeSymbol>();
-                var declarationsGenerated = new HashSet<string>();
-                var deltaType = compilation.GetTypeByMetadataName(ComponentDeltaInterfaceName)!;
+                // TODO: deduplicate based on name?
+                var (name, code) = source!.Value;
 
-                foreach (var declaration in declarations)
-                {
-                    builder.Clear();
-                    containingTypes.Clear();
-
-                    var type = compilation.GetSemanticModel(declaration.SyntaxTree).GetDeclaredSymbol(declaration)!;
-
-                    var symbolName = type
-                        .ToDisplayString()
-                        .Replace('<', '{')
-                        .Replace('>', '}');
-
-                    if (!declarationsGenerated.Add(symbolName))
-                        continue;
-
-                    var nonPartial = !IsPartial(declaration);
-
-                    var namespaceString = type.ContainingNamespace.IsGlobalNamespace
-                        ? string.Empty
-                        : $"namespace {type.ContainingNamespace.ToDisplayString()};";
-
-                    var containingType = type.ContainingType;
-                    while (containingType != null)
-                    {
-                        containingTypes.Push(containingType);
-                        containingType = containingType.ContainingType;
-                    }
-
-                    var containingTypesStart = new StringBuilder();
-                    var containingTypesEnd = new StringBuilder();
-                    foreach (var parent in containingTypes)
-                    {
-                        var syntax = (ClassDeclarationSyntax) parent.DeclaringSyntaxReferences[0].GetSyntax();
-                        if (!IsPartial(syntax))
-                        {
-                            nonPartial = true;
-                            continue;
-                        }
-
-                        containingTypesStart.AppendLine($"{GetPartialTypeDefinitionLine(parent)}\n{{");
-                        containingTypesEnd.AppendLine("}");
-                    }
-
-                    var definition = GetDataDefinition(type);
-                    if (nonPartial || definition.InvalidFields)
-                        continue;
-
-                    builder.AppendLine($$"""
-#nullable enable
-using System;
-using Robust.Shared.Analyzers;
-using Robust.Shared.IoC;
-using Robust.Shared.GameObjects;
-using Robust.Shared.Serialization;
-using Robust.Shared.Serialization.Manager;
-using Robust.Shared.Serialization.Manager.Exceptions;
-using Robust.Shared.Serialization.TypeSerializers.Interfaces;
-#pragma warning disable CS0618 // Type or member is obsolete
-#pragma warning disable CS0612 // Type or member is obsolete
-#pragma warning disable CS0108 // Member hides inherited member; missing new keyword
-#pragma warning disable RA0002 // Robust access analyzer
-
-{{namespaceString}}
-
-{{containingTypesStart}}
-
-{{GetPartialTypeDefinitionLine(type)}} : ISerializationGenerated<{{definition.GenericTypeName}}>
-{
-    {{GetConstructor(definition)}}
-
-    {{GetCopyMethods(definition, deltaType)}}
-
-    {{GetInstantiators(definition, deltaType)}}
-}
-
-{{containingTypesEnd}}
-""");
-
-                    var sourceText = CSharpSyntaxTree
-                        .ParseText(builder.ToString())
-                        .GetRoot()
-                        .NormalizeWhitespace()
-                        .ToFullString();
-
-                    sourceContext.AddSource($"{symbolName}.g.cs", sourceText);
-                }
+                sourceContext.AddSource(name, code);
             }
         );
     }
 
+    private static (string, string)? GenerateForDataDefinition(
+        TypeDeclarationSyntax declaration,
+        ITypeSymbol type)
+    {
+        var builder = new StringBuilder();
+        var containingTypes = new Stack<INamedTypeSymbol>();
+        containingTypes.Clear();
+
+        var symbolName = type
+            .ToDisplayString()
+            .Replace('<', '{')
+            .Replace('>', '}');
+
+        var nonPartial = !IsPartial(declaration);
+
+        var namespaceString = type.ContainingNamespace.IsGlobalNamespace
+            ? string.Empty
+            : $"namespace {type.ContainingNamespace.ToDisplayString()};";
+
+        var containingType = type.ContainingType;
+        while (containingType != null)
+        {
+            containingTypes.Push(containingType);
+            containingType = containingType.ContainingType;
+        }
+
+        var containingTypesStart = new StringBuilder();
+        var containingTypesEnd = new StringBuilder();
+        foreach (var parent in containingTypes)
+        {
+            var syntax = (ClassDeclarationSyntax)parent.DeclaringSyntaxReferences[0].GetSyntax();
+            if (!IsPartial(syntax))
+            {
+                nonPartial = true;
+                continue;
+            }
+
+            containingTypesStart.AppendLine($"{GetPartialTypeDefinitionLine(parent)}\n{{");
+            containingTypesEnd.AppendLine("}");
+        }
+
+        var definition = GetDataDefinition(type);
+        if (nonPartial || definition.InvalidFields)
+            return null;
+
+        builder.AppendLine($$"""
+            #nullable enable
+            using System;
+            using Robust.Shared.Analyzers;
+            using Robust.Shared.IoC;
+            using Robust.Shared.GameObjects;
+            using Robust.Shared.Serialization;
+            using Robust.Shared.Serialization.Manager;
+            using Robust.Shared.Serialization.Manager.Exceptions;
+            using Robust.Shared.Serialization.TypeSerializers.Interfaces;
+            #pragma warning disable CS0618 // Type or member is obsolete
+            #pragma warning disable CS0612 // Type or member is obsolete
+            #pragma warning disable CS0108 // Member hides inherited member; missing new keyword
+            #pragma warning disable RA0002 // Robust access analyzer
+
+            {{namespaceString}}
+
+            {{containingTypesStart}}
+
+            {{GetPartialTypeDefinitionLine(type)}} : ISerializationGenerated<{{definition.GenericTypeName}}>
+            {
+                {{GetConstructor(definition)}}
+
+                {{GetCopyMethods(definition)}}
+
+                {{GetInstantiators(definition)}}
+            }
+
+            {{containingTypesEnd}}
+            """);
+
+        return ($"{symbolName}.g.cs", builder.ToString());
+    }
+
     private static DataDefinition GetDataDefinition(ITypeSymbol definition)
     {
         var fields = new List<DataField>();
@@ -196,7 +191,7 @@ using Robust.Shared.Serialization.TypeSerializers.Interfaces;
          return builder.ToString();
      }
 
-    private static string GetCopyMethods(DataDefinition definition, ITypeSymbol deltaType)
+    private static string GetCopyMethods(DataDefinition definition)
     {
         var builder = new StringBuilder();
 
@@ -267,36 +262,36 @@ using Robust.Shared.Serialization.TypeSerializers.Interfaces;
                              {{baseCopy}}
                              """);
 
-        foreach (var @interface in InternalGetImplicitDataDefinitionInterfaces(definition.Type, true, deltaType))
+        foreach (var interfaceName in InternalGetImplicitDataDefinitionInterfaces(definition.Type, true))
         {
-            var interfaceModifiers = baseType != null && baseType.AllInterfaces.Contains(@interface, SymbolEqualityComparer.Default)
+            var interfaceModifiers = baseType != null &&
+                                     baseType.AllInterfaces.Any(i => i.ToDisplayString() == interfaceName)
                 ? "override "
                 : modifiers;
-            var interfaceName = @interface.ToDisplayString();
 
             builder.AppendLine($$"""
-                                 /// <seealso cref="ISerializationManager.CopyTo"/>
-                                 [Obsolete("Use ISerializationManager.CopyTo instead")]
-                                 public {{interfaceModifiers}} void InternalCopy(ref {{interfaceName}} target, ISerializationManager serialization, SerializationHookContext hookCtx, ISerializationContext? context = null)
-                                 {
-                                     var def = ({{definition.GenericTypeName}}) target;
-                                     Copy(ref def, serialization, hookCtx, context);
-                                     target = def;
-                                 }
+                /// <seealso cref="ISerializationManager.CopyTo"/>
+                [Obsolete("Use ISerializationManager.CopyTo instead")]
+                public {{interfaceModifiers}} void InternalCopy(ref {{interfaceName}} target, ISerializationManager serialization, SerializationHookContext hookCtx, ISerializationContext? context = null)
+                {
+                    var def = ({{definition.GenericTypeName}}) target;
+                    Copy(ref def, serialization, hookCtx, context);
+                    target = def;
+                }
 
-                                 /// <seealso cref="ISerializationManager.CopyTo"/>
-                                 [Obsolete("Use ISerializationManager.CopyTo instead")]
-                                 public {{interfaceModifiers}} void Copy(ref {{interfaceName}} target, ISerializationManager serialization, SerializationHookContext hookCtx, ISerializationContext? context = null)
-                                 {
-                                     InternalCopy(ref target, serialization, hookCtx, context);
-                                 }
-                                 """);
+                /// <seealso cref="ISerializationManager.CopyTo"/>
+                [Obsolete("Use ISerializationManager.CopyTo instead")]
+                public {{interfaceModifiers}} void Copy(ref {{interfaceName}} target, ISerializationManager serialization, SerializationHookContext hookCtx, ISerializationContext? context = null)
+                {
+                    InternalCopy(ref target, serialization, hookCtx, context);
+                }
+                """);
         }
 
         return builder.ToString();
     }
 
-    private static string GetInstantiators(DataDefinition definition, ITypeSymbol deltaType)
+    private static string GetInstantiators(DataDefinition definition)
     {
         var builder = new StringBuilder();
         var modifiers = string.Empty;
@@ -330,27 +325,28 @@ using Robust.Shared.Serialization.TypeSerializers.Interfaces;
                                  """);
         }
 
-        foreach (var @interface in InternalGetImplicitDataDefinitionInterfaces(definition.Type, false, deltaType))
+        foreach (var interfaceName in InternalGetImplicitDataDefinitionInterfaces(definition.Type, false))
         {
-            var interfaceName = @interface.ToDisplayString();
             builder.AppendLine($$"""
-                                 {{interfaceName}} {{interfaceName}}.Instantiate()
-                                 {
-                                     return Instantiate();
-                                 }
+                {{interfaceName}} {{interfaceName}}.Instantiate()
+                {
+                    return Instantiate();
+                }
 
-                                 {{interfaceName}} ISerializationGenerated<{{interfaceName}}>.Instantiate()
-                                 {
-                                     return Instantiate();
-                                 }
-                                 """);
+                {{interfaceName}} ISerializationGenerated<{{interfaceName}}>.Instantiate()
+                {
+                    return Instantiate();
+                }
+                """);
         }
 
         return builder.ToString();
     }
 
     [SuppressMessage("ReSharper", "PossibleMultipleEnumeration")]
-    private static IEnumerable<ITypeSymbol> InternalGetImplicitDataDefinitionInterfaces(ITypeSymbol type, bool all, ITypeSymbol deltaType)
+    private static IEnumerable<string> InternalGetImplicitDataDefinitionInterfaces(
+        ITypeSymbol type,
+        bool all)
     {
         var symbols = GetImplicitDataDefinitionInterfaces(type, all);
 
@@ -368,10 +364,10 @@ using Robust.Shared.Serialization.TypeSerializers.Interfaces;
             return symbols;
         }
 
-        if (symbols.Any(x => x.ToDisplayString() == deltaType.ToDisplayString()))
+        if (symbols.Any(x => x == ComponentDeltaInterfaceName))
             return symbols;
 
-        return symbols.Append(deltaType);
+        return symbols.Append(ComponentDeltaInterfaceName);
     }
 
     // TODO serveronly? do we care? who knows!!

Robust.Serialization.Generator/Types.cs

@@ -94,13 +94,13 @@ internal static class Types
         return false;
     }
 
-    internal static IEnumerable<ITypeSymbol> GetImplicitDataDefinitionInterfaces(ITypeSymbol type, bool all)
+    internal static IEnumerable<string> GetImplicitDataDefinitionInterfaces(ITypeSymbol type, bool all)
     {
         var interfaces = all ? type.AllInterfaces : type.Interfaces;
         foreach (var @interface in interfaces)
         {
             if (IsImplicitDataDefinitionInterface(@interface))
-                yield return @interface;
+                yield return @interface.ToDisplayString();
         }
     }
 

Robust.Server/BaseServer.cs

@@ -297,7 +297,7 @@ namespace Robust.Server
                 : null;
 
             // Set up the VFS
-            _resources.Initialize(dataDir);
+            _resources.Initialize(dataDir, hideUserDataDir: false);
 
             var mountOptions = _commandLineArgs != null
                 ? MountOptions.Merge(_commandLineArgs.MountOptions, Options.MountOptions) : Options.MountOptions;

Robust.Shared.Maths/Properties/AssemblyInfo.cs

@@ -6,4 +6,3 @@
 
 [assembly: InternalsVisibleTo("Robust.Client")]
 [assembly: InternalsVisibleTo("Robust.UnitTesting")]
-[assembly: InternalsVisibleTo("Content.Benchmarks")]

Robust.Shared/ContentPack/AssemblyTypeChecker.Config.cs

@@ -88,6 +88,7 @@ namespace Robust.Shared.ContentPack
             public string SystemAssemblyName = default!;
             public HashSet<VerifierError> AllowedVerifierErrors = default!;
             public List<string> WhitelistedNamespaces = default!;
+            public List<string> AllowedAssemblyPrefixes = default!;
             public Dictionary<string, Dictionary<string, TypeConfig>> Types = default!;
         }
 

Robust.Shared/ContentPack/AssemblyTypeChecker.cs

@@ -131,6 +131,16 @@ namespace Robust.Shared.ContentPack
                 return false;
             }
 
+#pragma warning disable RA0004
+            var loadedConfig = _config.Result;
+#pragma warning restore RA0004
+
+            if (!loadedConfig.AllowedAssemblyPrefixes.Any(allowedNamePrefix => asmName.StartsWith(allowedNamePrefix)))
+            {
+                _sawmill.Error($"Assembly name '{asmName}' is not allowed for a content assembly");
+                return false;
+            }
+
             if (VerifyIL)
             {
                 if (!DoVerifyIL(asmName, resolver, peReader, reader))
@@ -179,10 +189,6 @@ namespace Robust.Shared.ContentPack
                 return true;
             }
 
-#pragma warning disable RA0004
-            var loadedConfig = _config.Result;
-#pragma warning restore RA0004
-
             var badRefs = new ConcurrentBag<EntityHandle>();
 
             // We still do explicit type reference scanning, even though the actual whitelists work with raw members.

Robust.Shared/ContentPack/DirLoader.cs

@@ -60,7 +60,7 @@ namespace Robust.Shared.ContentPack
 
             internal string GetPath(ResPath relPath)
             {
-                return Path.GetFullPath(Path.Combine(_directory.FullName, relPath.ToRelativeSystemPath()));
+                return PathHelpers.SafeGetResourcePath(_directory.FullName, relPath);
             }
 
             /// <inheritdoc />

Robust.Shared/ContentPack/IResourceManagerInternal.cs

@@ -14,7 +14,11 @@ namespace Robust.Shared.ContentPack
         /// The directory to use for user data.
         /// If null, a virtual temporary file system is used instead.
         /// </param>
-        void Initialize(string? userData);
+        /// <param name="hideUserDataDir">
+        /// If true, <see cref="IWritableDirProvider.RootDir"/> will be hidden on
+        /// <see cref="IResourceManager.UserData"/>.
+        /// </param>
+        void Initialize(string? userData, bool hideUserDataDir);
 
         /// <summary>
         ///     Mounts a single stream as a content file. Useful for unit testing.

Robust.Shared/ContentPack/IWritableDirProvider.cs

@@ -13,7 +13,7 @@ namespace Robust.Shared.ContentPack
     {
         /// <summary>
         /// The root path of this provider.
-        /// Can be null if it's a virtual provider.
+        /// Can be null if it's a virtual provider or the path is protected (e.g. on the client).
         /// </summary>
         string? RootDir { get; }
 

Robust.Shared/ContentPack/ModLoader.cs

@@ -93,19 +93,23 @@ namespace Robust.Shared.ContentPack
         {
             var sw = Stopwatch.StartNew();
             Sawmill.Debug("LOADING modules");
-            var files = new Dictionary<string, (ResPath Path, string[] references)>();
+            var files = new Dictionary<string, (ResPath Path, MemoryStream data, string[] references)>();
 
             // Find all modules we want to load.
             foreach (var fullPath in paths)
             {
                 using var asmFile = _res.ContentFileRead(fullPath);
-                var refData = GetAssemblyReferenceData(asmFile);
+                var ms = new MemoryStream();
+                asmFile.CopyTo(ms);
+
+                ms.Position = 0;
+                var refData = GetAssemblyReferenceData(ms);
                 if (refData == null)
                     continue;
 
                 var (asmRefs, asmName) = refData.Value;
 
-                if (!files.TryAdd(asmName, (fullPath, asmRefs)))
+                if (!files.TryAdd(asmName, (fullPath, ms, asmRefs)))
                 {
                     Sawmill.Error("Found multiple modules with the same assembly name " +
                                   $"'{asmName}', A: {files[asmName].Path}, B: {fullPath}.");
@@ -122,10 +126,10 @@ namespace Robust.Shared.ContentPack
 
                 Parallel.ForEach(files, pair =>
                 {
-                    var (name, (path, _)) = pair;
+                    var (name, (_, data, _)) = pair;
 
-                    using var stream = _res.ContentFileRead(path);
-                    if (!typeChecker.CheckAssembly(stream, resolver))
+                    data.Position = 0;
+                    if (!typeChecker.CheckAssembly(data, resolver))
                     {
                         throw new TypeCheckFailedException($"Assembly {name} failed type checks.");
                     }
@@ -137,14 +141,15 @@ namespace Robust.Shared.ContentPack
             var nodes = TopologicalSort.FromBeforeAfter(
                 files,
                 kv => kv.Key,
-                kv => kv.Value.Path,
+                kv => kv.Value,
                 _ => Array.Empty<string>(),
                 kv => kv.Value.references,
                 allowMissing: true); // missing refs would be non-content assemblies so allow that.
 
             // Actually load them in the order they depend on each other.
-            foreach (var path in TopologicalSort.Sort(nodes))
+            foreach (var item in TopologicalSort.Sort(nodes))
             {
+                var (path, memory, _) = item;
                 Sawmill.Debug($"Loading module: '{path}'");
                 try
                 {
@@ -156,9 +161,9 @@ namespace Robust.Shared.ContentPack
                     }
                     else
                     {
-                        using var assemblyStream = _res.ContentFileRead(path);
+                        memory.Position = 0;
                         using var symbolsStream = _res.ContentFileReadOrNull(path.WithExtension("pdb"));
-                        LoadGameAssembly(assemblyStream, symbolsStream, skipVerify: true);
+                        LoadGameAssembly(memory, symbolsStream, skipVerify: true);
                     }
                 }
                 catch (Exception e)
@@ -174,7 +179,7 @@ namespace Robust.Shared.ContentPack
 
         private (string[] refs, string name)? GetAssemblyReferenceData(Stream stream)
         {
-            using var reader = ModLoader.MakePEReader(stream);
+            using var reader = ModLoader.MakePEReader(stream, leaveOpen: true);
             var metaReader = reader.GetMetadataReader();
 
             var name = metaReader.GetString(metaReader.GetAssemblyDefinition().Name);

Robust.Shared/ContentPack/PathHelpers.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Runtime.InteropServices;
+using Robust.Shared.Utility;
 
 namespace Robust.Shared.ContentPack
 {
@@ -63,5 +64,27 @@ namespace Robust.Shared.ContentPack
             !OperatingSystem.IsWindows()
             && !OperatingSystem.IsMacOS();
 
+
+        internal static string SafeGetResourcePath(string baseDir, ResPath path)
+        {
+            var relSysPath = path.ToRelativeSystemPath();
+            if (relSysPath.Contains("\\..") || relSysPath.Contains("/.."))
+            {
+                // Hard cap on any exploit smuggling a .. in there.
+                // Since that could allow leaving sandbox.
+                throw new InvalidOperationException($"This branch should never be reached. Path: {path}");
+            }
+
+            var retPath = Path.GetFullPath(Path.Join(baseDir, relSysPath));
+            // better safe than sorry check
+            if (!retPath.StartsWith(baseDir))
+            {
+                // Allow path to match if it's just missing the directory separator at the end.
+                if (retPath != baseDir.TrimEnd(Path.DirectorySeparatorChar))
+                    throw new InvalidOperationException($"This branch should never be reached. Path: {path}");
+            }
+
+            return retPath;
+        }
     }
 }

Robust.Shared/ContentPack/ResourceManager.cs

@@ -41,13 +41,13 @@ namespace Robust.Shared.ContentPack
         public IWritableDirProvider UserData { get; private set; } = default!;
 
         /// <inheritdoc />
-        public virtual void Initialize(string? userData)
+        public virtual void Initialize(string? userData, bool hideRootDir)
         {
             Sawmill = _logManager.GetSawmill("res");
 
             if (userData != null)
             {
-                UserData = new WritableDirProvider(Directory.CreateDirectory(userData));
+                UserData = new WritableDirProvider(Directory.CreateDirectory(userData), hideRootDir);
             }
             else
             {
@@ -379,7 +379,13 @@ namespace Robust.Shared.ContentPack
             {
                 if (root is DirLoader loader)
                 {
-                    yield return new ResPath(loader.GetPath(new ResPath(@"/")));
+                    var rootDir = loader.GetPath(new ResPath(@"/"));
+
+                    // TODO: GET RID OF THIS.
+                    // This code shouldn't be passing OS disk paths through ResPath.
+                    rootDir = rootDir.Replace(Path.DirectorySeparatorChar, '/');
+
+                    yield return new ResPath(rootDir);
                 }
             }
         }

Robust.Shared/ContentPack/Sandbox.yml

@@ -17,6 +17,10 @@ WhitelistedNamespaces:
 - Content
 - OpenDreamShared
 
+AllowedAssemblyPrefixes:
+- OpenDream
+- Content
+
 # The type whitelist does NOT care about which assembly types come from.
 # This is because types switch assembly all the time.
 # Just look up stuff like StreamReader on https://apisof.net.

Robust.Shared/ContentPack/WritableDirProvider.cs

@@ -10,17 +10,22 @@ namespace Robust.Shared.ContentPack
     /// <inheritdoc />
     internal sealed class WritableDirProvider : IWritableDirProvider
     {
-        /// <inheritdoc />
+        private readonly bool _hideRootDir;
+
         public string RootDir { get; }
 
+        string? IWritableDirProvider.RootDir => _hideRootDir ? null : RootDir;
+
         /// <summary>
         /// Constructs an instance of <see cref="WritableDirProvider"/>.
         /// </summary>
         /// <param name="rootDir">Root file system directory to allow writing.</param>
-        public WritableDirProvider(DirectoryInfo rootDir)
+        /// <param name="hideRootDir">If true, <see cref="IWritableDirProvider.RootDir"/> is reported as null.</param>
+        public WritableDirProvider(DirectoryInfo rootDir, bool hideRootDir)
         {
             // FullName does not have a trailing separator, and we MUST have a separator.
             RootDir = rootDir.FullName + Path.DirectorySeparatorChar.ToString();
+            _hideRootDir = hideRootDir;
         }
 
         #region File Access
@@ -119,7 +124,7 @@ namespace Robust.Shared.ContentPack
                 throw new FileNotFoundException();
 
             var dirInfo = new DirectoryInfo(GetFullPath(path));
-            return new WritableDirProvider(dirInfo);
+            return new WritableDirProvider(dirInfo, _hideRootDir);
         }
 
         /// <inheritdoc />
@@ -180,20 +185,7 @@ namespace Robust.Shared.ContentPack
 
             path = path.Clean();
 
-            return GetFullPath(RootDir, path);
-        }
-
-        private static string GetFullPath(string root, ResPath path)
-        {
-            var relPath = path.ToRelativeSystemPath();
-            if (relPath.Contains("\\..") || relPath.Contains("/.."))
-            {
-                // Hard cap on any exploit smuggling a .. in there.
-                // Since that could allow leaving sandbox.
-                throw new InvalidOperationException($"This branch should never be reached. Path: {path}");
-            }
-
-            return Path.GetFullPath(Path.Combine(root, relPath));
+            return PathHelpers.SafeGetResourcePath(RootDir, path);
         }
     }
 }

Robust.Shared/Network/NetManager.cs

@@ -957,7 +957,7 @@ namespace Robust.Shared.Network
             }
 
             if (_loggerPacket.IsLogLevelEnabled(LogLevel.Verbose))
-                _loggerPacket.Verbose("net", $"RECV: {instance.GetType().Name} {msg.LengthBytes}");
+                _loggerPacket.Verbose($"RECV: {instance.GetType().Name} {msg.LengthBytes}");
 
             try
             {

Robust.Shared/Properties/AssemblyInfo.cs

@@ -9,7 +9,6 @@
 [assembly: InternalsVisibleTo("Robust.UnitTesting")]
 [assembly: InternalsVisibleTo("OpenToolkit.GraphicsLibraryFramework")]
 [assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")] // Gives access to Castle(Moq)
-[assembly: InternalsVisibleTo("Content.Benchmarks")]
 [assembly: InternalsVisibleTo("Robust.Benchmarks")]
 [assembly: InternalsVisibleTo("Robust.Client.WebView")]
 [assembly: InternalsVisibleTo("Robust.Packaging")]

Robust.Shared/Serialization/NetBitArraySerializer.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.Serialization;
+using JetBrains.Annotations;
+using NetSerializer;
+
+namespace Robust.Shared.Serialization;
+
+/// <summary>
+/// Custom serializer implementation for <see cref="BitArray"/>.
+/// </summary>
+/// <remarks>
+/// <para>
+/// This type is necessary as, since .NET 10, the internal layout of <see cref="BitArray"/> was changed.
+/// The type now (internally) implements <see cref="ISerializable"/> for backwards compatibility with existing
+/// <c>BinaryFormatter</c> code, but NetSerializer does not support <see cref="ISerializable"/>.
+/// </para>
+/// <para>
+/// This code is designed to be backportable &amp; network compatible with the previous behavior on .NET 9.
+/// </para>
+/// </remarks>
+internal sealed class NetBitArraySerializer : IDynamicTypeSerializer
+{
+    // NOTE: MUST be a IDynamicTypeSerializer for compatibility!
+    // Can be changed in the future.
+
+    // For reference, the layout of BitArray before .NET 10 was:
+    // private int[] m_array;
+    // private int m_length;
+    // private int _version;
+    // NetSerializer serialized these in the following order (sorted by name):
+    // _version, m_array, m_length
+
+    public bool Handles(Type type)
+    {
+        return type == typeof(BitArray);
+    }
+
+    public IEnumerable<Type> GetSubtypes(Type type)
+    {
+        return [typeof(int[]), typeof(int)];
+    }
+
+    public void GenerateWriterMethod(Serializer serializer, Type type, ILGenerator il)
+    {
+        var method = typeof(NetBitArraySerializer).GetMethod("Write", BindingFlags.Static | BindingFlags.NonPublic)!;
+
+        // arg0: Serializer, arg1: Stream, arg2: value
+        il.Emit(OpCodes.Ldarg_0);
+        il.Emit(OpCodes.Ldarg_1);
+        il.Emit(OpCodes.Ldarg_2);
+
+        il.EmitCall(OpCodes.Call, method, null);
+
+        il.Emit(OpCodes.Ret);
+    }
+
+    public void GenerateReaderMethod(Serializer serializer, Type type, ILGenerator il)
+    {
+        var method = typeof(NetBitArraySerializer).GetMethod("Read", BindingFlags.Static | BindingFlags.NonPublic)!;
+
+        // arg0: Serializer, arg1: stream, arg2: out value
+        il.Emit(OpCodes.Ldarg_0);
+        il.Emit(OpCodes.Ldarg_1);
+        il.Emit(OpCodes.Ldarg_2);
+
+        il.EmitCall(OpCodes.Call, method, null);
+
+        il.Emit(OpCodes.Ret);
+    }
+
+    [UsedImplicitly]
+    private static void Write(Serializer serializer, Stream stream, BitArray value)
+    {
+        var intCount = (31 + value.Length) >> 5;
+        var ints = new int[intCount];
+        value.CopyTo(ints, 0);
+
+        serializer.SerializeDirect(stream, 0); // _version
+        serializer.SerializeDirect(stream, ints); // m_array
+        serializer.SerializeDirect(stream, value.Length); // m_length
+    }
+
+    [UsedImplicitly]
+    private static void Read(Serializer serializer, Stream stream, out BitArray value)
+    {
+        serializer.DeserializeDirect<int>(stream, out _); // _version
+        serializer.DeserializeDirect<int[]>(stream, out var array); // m_array
+        serializer.DeserializeDirect<int>(stream, out var length); // m_length
+
+        value = new BitArray(array)
+        {
+            Length = length
+        };
+    }
+}

Robust.Shared/Serialization/RobustSerializer.cs

@@ -91,6 +91,7 @@ namespace Robust.Shared.Serialization
                     MappedStringSerializer.TypeSerializer,
                     new Vector2Serializer(),
                     new Matrix3x2Serializer(),
+                    new NetBitArraySerializer()
                 }
             };
             _serializer = new Serializer(types, settings);

Robust.UnitTesting/Shared/Resources/WritableDirProviderTest.cs

@@ -24,7 +24,7 @@ namespace Robust.UnitTesting.Shared.Resources
             _testDir = Directory.CreateDirectory(_testDirPath);
             var subDir = Path.Combine(_testDirPath, "writable");
 
-            _dirProvider = new WritableDirProvider(Directory.CreateDirectory(subDir));
+            _dirProvider = new WritableDirProvider(Directory.CreateDirectory(subDir), hideRootDir: false);
         }
 
         [OneTimeTearDown]

Tools/package_webview.py

@@ -33,6 +33,8 @@ PLATFORM_LINUX = "linux-x64"
 PLATFORM_LINUX_ARM64 = "linux-arm64"
 PLATFORM_MACOS = "osx-x64"
 
+TARGET_FRAMEWORK = "net9.0"
+
 def main() -> None:
     parser = argparse.ArgumentParser(
         description="Packages the Robust.Client.WebView module for release on all platforms.")
@@ -85,7 +87,7 @@ def build_windows(skip_build: bool) -> None:
     # Run a full build.
     print(Fore.GREEN + "Building project for Windows x64..." + Style.RESET_ALL)
 
-    base_bin = p("Robust.Client.WebView", "bin", "Release", "net8.0")
+    base_bin = p("Robust.Client.WebView", "bin", "Release", TARGET_FRAMEWORK)
 
     if not skip_build:
         build_client_rid("Windows", "win-x64")
@@ -144,7 +146,7 @@ def build_linux(skip_build: bool) -> None:
     # Run a full build.
     print(Fore.GREEN + "Building project for Linux x64..." + Style.RESET_ALL)
 
-    base_bin = p("Robust.Client.WebView", "bin", "Release", "net8.0")
+    base_bin = p("Robust.Client.WebView", "bin", "Release", TARGET_FRAMEWORK)
 
     if not skip_build:
         build_client_rid("Linux", "linux-x64")