Don't rename/strip framework-reserved "magic" types (#97)

Compiler/runtime-recognised types (PolySharp-style polyfills such as
System.Runtime.CompilerServices.IsExternalInit / RequiredMemberAttribute,
System.Diagnostics.CodeAnalysis nullable attributes,
System.Runtime.InteropServices.UnmanagedCallersOnlyAttribute,
System.Diagnostics.StackTraceHiddenAttribute, ...) are matched by their
exact full name. Renaming them - or stripping their namespace - silently
breaks the feature they back.

Add TypeDefinition.IsInReservedNamespace() listing the framework-owned
namespaces that only ever contain such shims in a user assembly, and skip
them in both FullRenamer (Renamer.ShouldRenameType / RemoveNamespace) and
NoNamespaces. Verified: polyfill types keep name+namespace while app types
are still renamed and stripped.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: sunnamed434

src/BitMono.Core/Renaming/Renamer.cs

@@ -31,7 +31,9 @@ public string RenameUnsafely()
 
     private bool ShouldRenameType(TypeDefinition? typeDefinition)
     {
-        return typeDefinition == null || (_nameCriticalAnalyzer.NotCriticalToMakeChanges(typeDefinition) && !typeDefinition.IsExplicitLayout);
+        // Types in framework-reserved namespaces (e.g. PolySharp polyfills) are matched by full
+        // name by the compiler/runtime and must never be renamed. See IsInReservedNamespace.
+        return typeDefinition == null || (_nameCriticalAnalyzer.NotCriticalToMakeChanges(typeDefinition) && !typeDefinition.IsExplicitLayout && !typeDefinition.IsInReservedNamespace());
     }
 
     /// <summary>
@@ -89,7 +91,7 @@ public void RemoveNamespace(IMetadataMember member)
     {
         if (member is TypeDefinition type)
         {
-            if (_specificNamespaceCriticalAnalyzer.NotCriticalToMakeChanges(type))
+            if (_specificNamespaceCriticalAnalyzer.NotCriticalToMakeChanges(type) && !type.IsInReservedNamespace())
             {
                 type.Namespace = string.Empty;
             }
@@ -98,15 +100,15 @@ public void RemoveNamespace(IMetadataMember member)
         {
             if (_nameCriticalAnalyzer.NotCriticalToMakeChanges(method))
             {
-                if (method.DeclaringType != null)
+                if (method.DeclaringType != null && !method.DeclaringType.IsInReservedNamespace())
                 {
                     method.DeclaringType.Namespace = string.Empty;
                 }
             }
         }
         if (member is FieldDefinition field)
         {
-            if (field.DeclaringType != null)
+            if (field.DeclaringType != null && !field.DeclaringType.IsInReservedNamespace())
             {
                 field.DeclaringType.Namespace = string.Empty;
             }

src/BitMono.Protections/NoNamespaces.cs

@@ -15,6 +15,12 @@ public override Task ExecuteAsync()
             {
                 continue;
             }
+            // Keep framework-reserved namespaces (e.g. PolySharp polyfills) intact - the
+            // compiler/runtime match those types by full name. See IsInReservedNamespace.
+            if (type.IsInReservedNamespace())
+            {
+                continue;
+            }
 
             type.Namespace = string.Empty;
         }

src/BitMono.Utilities/AsmResolver/TypeDefinitionExtensions.cs

@@ -11,6 +11,48 @@ public static bool HasNamespace(this TypeDefinition source)
         return Utf8String.IsNullOrEmpty(source.Namespace) == false;
     }
 
+    // Compiler/runtime-recognised "magic" types are matched by their exact full name, so when a
+    // project ships them as in-assembly polyfills/shims (e.g. PolySharp) they must keep their
+    // original name AND namespace - renaming or namespace-stripping silently breaks the feature
+    // they back. Real application code never lives in these framework-owned namespaces, so any
+    // type defined under them is left untouched. See
+    // https://github.com/sunnamed434/BitMono/issues/97.
+    //
+    //   System.Runtime.CompilerServices - IsExternalInit, RequiredMemberAttribute,
+    //       CompilerFeatureRequiredAttribute, ModuleInitializerAttribute, SkipLocalsInitAttribute,
+    //       CallerArgumentExpressionAttribute, InterpolatedStringHandler*, CallConv* markers, ...
+    //   System.Diagnostics.CodeAnalysis - nullable analysis attributes (AllowNull, NotNull,
+    //       MemberNotNull, ...), DynamicallyAccessedMembers, RequiresUnreferencedCode, ...
+    //   System.Runtime.Versioning      - SupportedOSPlatform/UnsupportedOSPlatform,
+    //       RequiresPreviewFeaturesAttribute, ...
+    //   System.Runtime.InteropServices - UnmanagedCallersOnlyAttribute is resolved by the runtime
+    //       by name to set up reverse P/Invoke; renaming it breaks the call.
+    //   System.Diagnostics             - StackTraceHiddenAttribute is read by the runtime by name
+    //       when formatting stack traces.
+    private static readonly string[] ReservedNamespaces =
+    {
+        "System.Runtime.CompilerServices",
+        "System.Diagnostics.CodeAnalysis",
+        "System.Runtime.Versioning",
+        "System.Runtime.InteropServices",
+        "System.Diagnostics",
+    };
+
+    /// <summary>
+    /// Whether the type lives in a framework-owned namespace that holds compiler/runtime
+    /// "magic" types matched by full name (e.g. PolySharp polyfills). Such types must never be
+    /// renamed nor have their namespace stripped.
+    /// </summary>
+    public static bool IsInReservedNamespace(this TypeDefinition? source)
+    {
+        var @namespace = source?.Namespace?.Value;
+        if (string.IsNullOrEmpty(@namespace))
+        {
+            return false;
+        }
+        return Array.IndexOf(ReservedNamespaces, @namespace) != -1;
+    }
+
     /// <summary>
     /// Gets the type and all its base types in the inheritance hierarchy.
     /// </summary>