Fix obfuscation attributes strip and do other refactoring

sunnamed434 · sunnamed434 · commit 4bb03e8c2ed8 · 2024-08-18T15:40:04.000+03:00
diff --git a/src/BitMono.API/Resolvers/IAttributeResolver.cs b/src/BitMono.API/Resolvers/IAttributeResolver.cs
@@ -1,9 +1,9 @@
 ﻿namespace BitMono.API.Resolvers;
 
-public interface IAttributeResolver<TModel>
-    where TModel : class
+[UsedImplicitly(ImplicitUseTargetFlags.WithInheritors)]
+public interface IAttributeResolver<TModel> where TModel : class
 {
-    bool Resolve(string? featureName, IHasCustomAttribute from, out TModel? model);
+    bool Resolve(string? featureName, IHasCustomAttribute from, [NotNullWhen(true)] out TModel? model);
     bool Resolve(string? featureName, IHasCustomAttribute from);
     bool Resolve(IHasCustomAttribute from);
     bool Resolve(Type featureType, IHasCustomAttribute from);
diff --git a/src/BitMono.API/Resolvers/IMemberResolver.cs b/src/BitMono.API/Resolvers/IMemberResolver.cs
@@ -1,5 +1,6 @@
 ﻿namespace BitMono.API.Resolvers;
 
+[UsedImplicitly(ImplicitUseTargetFlags.WithInheritors)]
 public interface IMemberResolver
 {
     bool Resolve(IProtection protection, IMetadataMember member);
diff --git a/src/BitMono.CLI/Program.cs b/src/BitMono.CLI/Program.cs
@@ -6,13 +6,15 @@ internal class Program
     private static CancellationToken CancellationToken => CancellationTokenSource.Token;
     private static readonly string BitMonoFileVersionText =
         $"BitMono v{FileVersionInfo.GetVersionInfo(typeof(Program).Assembly.Location).FileVersion}";
-    private static readonly string AsciiArt = @$"
-       ___  _ __  __  ___
-      / _ )(_) /_/  |/  /__  ___  ___
-     / _  / / __/ /|_/ / _ \/ _ \/ _ \
-    /____/_/\__/_/  /_/\___/_//_/\___/
-    https://github.com/sunnamed434/BitMono
-    {BitMonoFileVersionText}";
+    private static readonly string AsciiArt = $"""
+
+                                                      ___  _ __  __  ___
+                                                     / _ )(_) /_/  |/  /__  ___  ___
+                                                    / _  / / __/ /|_/ / _ \/ _ \/ _ \
+                                                   /____/_/\__/_/  /_/\___/_//_/\___/
+                                                   https://github.com/sunnamed434/BitMono
+                                                   {BitMonoFileVersionText}
+                                               """;
 
     private static async Task<int> Main(string[] args)
     {
@@ -53,7 +55,7 @@ private static async Task<int> Main(string[] args)
 
             var info = new IncompleteFileInfo(needs.FileName, needs.ReferencesDirectoryName, needs.OutputPath);
             var engine = new BitMonoStarter(serviceProvider);
-            var succeed = await engine.StartAsync(info, CancellationTokenSource.Token);
+            var succeed = await engine.StartAsync(info, CancellationToken);
             if (succeed == false)
             {
                 logger.Fatal("Engine has fatal issues, unable to continue!");
diff --git a/src/BitMono.Core/Analyzing/CriticalMethodsCriticalAnalyzer.cs b/src/BitMono.Core/Analyzing/CriticalMethodsCriticalAnalyzer.cs
@@ -1,6 +1,5 @@
 ﻿namespace BitMono.Core.Analyzing;
 
-[UsedImplicitly]
 public class CriticalMethodsCriticalAnalyzer : ICriticalAnalyzer<MethodDefinition>
 {
     private readonly CriticalsSettings _criticalsSettings;
diff --git a/src/BitMono.Core/Contexts/StarterContext.cs b/src/BitMono.Core/Contexts/StarterContext.cs
@@ -1,6 +1,5 @@
 ﻿namespace BitMono.Core.Contexts;
 
-[SuppressMessage("ReSharper", "UnusedAutoPropertyAccessor.Global")]
 public class StarterContext
 {
 #pragma warning disable CS8618
diff --git a/src/BitMono.Core/Extensions/KeyValuePairsExtensions.cs b/src/BitMono.Core/Extensions/KeyValuePairsExtensions.cs
@@ -11,7 +11,7 @@ public static bool GetValueOrDefault(this Dictionary<string, object> source, str
         }
         return value;
     }
-    public static bool TryGetTypedValue<TKey, TValue, TActual>(this IDictionary<TKey, TValue> source, TKey key, out TActual? value)
+    public static bool TryGetTypedValue<TKey, TValue, TActual>(this IDictionary<TKey, TValue> source, TKey key, [NotNullWhen(true)] out TActual? value)
         where TActual : TValue
     {
         if (source.TryGetValue(key, out var tempValue))
diff --git a/src/BitMono.Core/Resolvers/AttemptAttributeResolver.cs b/src/BitMono.Core/Resolvers/AttemptAttributeResolver.cs
@@ -2,7 +2,8 @@
 
 public static class AttemptAttributeResolver
 {
-    public static bool TryResolve(IHasCustomAttribute from, string @namespace, string name, out List<CustomAttributeResolve>? attributesResolve)
+    public static bool TryResolve(IHasCustomAttribute from, string @namespace, string name,
+        [NotNullWhen(true)] out List<CustomAttributeResolve>? attributesResolve)
     {
         attributesResolve = CustomAttributeResolver.Resolve(from, @namespace, name);
         return attributesResolve.IsNullOrEmpty() == false;
diff --git a/src/BitMono.Core/Resolvers/AttributeResolver.cs b/src/BitMono.Core/Resolvers/AttributeResolver.cs
@@ -2,7 +2,7 @@
 
 public class AttributeResolver<TModel> : IAttributeResolver<TModel> where TModel : class
 {
-    public virtual bool Resolve(string? featureName, IHasCustomAttribute from, out TModel? model)
+    public virtual bool Resolve(string? featureName, IHasCustomAttribute from, [NotNullWhen(true)] out TModel? model)
     {
         model = default;
         return false;
diff --git a/src/BitMono.Core/Resolvers/CriticalAttributeResolver.cs b/src/BitMono.Core/Resolvers/CriticalAttributeResolver.cs
@@ -1,8 +1,5 @@
 ﻿namespace BitMono.Core.Resolvers;
 
-[UsedImplicitly]
-[SuppressMessage("ReSharper", "InvertIf")]
-[SuppressMessage("ReSharper", "ForCanBeConvertedToForeach")]
 public class CriticalAttributeResolver : AttributeResolver<CustomAttributeResolve>
 {
     private readonly CriticalsSettings _criticalsSettings;
@@ -13,7 +10,7 @@ public CriticalAttributeResolver(IOptions<CriticalsSettings> criticals)
     }
 
     public override bool Resolve(string? feature, IHasCustomAttribute from,
-        out CustomAttributeResolve? attributeResolve)
+        [NotNullWhen(true)] out CustomAttributeResolve? attributeResolve)
     {
         attributeResolve = null;
         if (_criticalsSettings.UseCriticalAttributes == false)
@@ -22,17 +19,17 @@ public override bool Resolve(string? feature, IHasCustomAttribute from,
         }
 
         var criticalAttributes = _criticalsSettings.CriticalAttributes;
-        for (var i = 0; i < criticalAttributes.Count; i++)
+        foreach (var criticalAttribute in criticalAttributes)
         {
-            var criticalAttribute = criticalAttributes[i];
             if (AttemptAttributeResolver.TryResolve(from, criticalAttribute.Namespace, criticalAttribute.Name,
-                    out var attributesResolve))
+                    out var attributesResolve) == false)
             {
-                attributeResolve = attributesResolve!.First();
-                return true;
+                continue;
             }
-        }
 
+            attributeResolve = attributesResolve.First();
+            return true;
+        }
         return false;
     }
 }
diff --git a/src/BitMono.Core/Resolvers/DoNotResolveMemberResolver.cs b/src/BitMono.Core/Resolvers/DoNotResolveMemberResolver.cs
@@ -1,7 +1,5 @@
 ﻿namespace BitMono.Core.Resolvers;
 
-[UsedImplicitly]
-[SuppressMessage("ReSharper", "InvertIf")]
 public class DoNotResolveMemberResolver : IMemberResolver
 {
     private readonly RuntimeCriticalAnalyzer _runtimeCriticalAnalyzer;
diff --git a/src/BitMono.Core/Resolvers/NoInliningMethodMemberResolver.cs b/src/BitMono.Core/Resolvers/NoInliningMethodMemberResolver.cs
@@ -1,7 +1,5 @@
 ﻿namespace BitMono.Core.Resolvers;
 
-[SuppressMessage("ReSharper", "InvertIf")]
-[SuppressMessage("ReSharper", "MergeIntoPattern")]
 public class NoInliningMethodMemberResolver : IMemberResolver
 {
     private readonly ObfuscationSettings _obfuscationSettings;
diff --git a/src/BitMono.Core/Resolvers/ObfuscateAssemblyAttributeResolver.cs b/src/BitMono.Core/Resolvers/ObfuscateAssemblyAttributeResolver.cs
@@ -9,11 +9,11 @@ public class ObfuscateAssemblyAttributeResolver : AttributeResolver<ObfuscateAss
     public ObfuscateAssemblyAttributeResolver(IOptions<ObfuscationSettings> configuration)
     {
         _obfuscationSettings = configuration.Value;
-        _attributeNamespace = typeof(ObfuscateAssemblyAttribute).Namespace;
+        _attributeNamespace = typeof(ObfuscateAssemblyAttribute).Namespace!;
         _attributeName = nameof(ObfuscateAssemblyAttribute);
     }
 
-    public override bool Resolve(string? feature, IHasCustomAttribute from, out ObfuscateAssemblyAttributeData? model)
+    public override bool Resolve(string? feature, IHasCustomAttribute from, [NotNullWhen(true)] out ObfuscateAssemblyAttributeData? model)
     {
         model = null;
         if (_obfuscationSettings.ObfuscateAssemblyAttributeObfuscationExclude == false)
@@ -25,11 +25,24 @@ public override bool Resolve(string? feature, IHasCustomAttribute from, out Obfu
         {
             return false;
         }
+        var attribute = attributesResolve.First();
+        var namedValues = attribute.NamedValues;
+        if (namedValues == null)
+        {
+            return false;
+        }
+        var fixedValues = attribute.FixedValues;
+        if (fixedValues == null || fixedValues.Count == 0)
+        {
+            return false;
+        }
+        if (fixedValues.ElementAtOrDefault(0) is not bool assemblyIsPrivate)
+        {
+            return false;
+        }
 
-        var attribute = attributesResolve!.First();
-        var assemblyIsPrivate = attribute.FixedValues![0] is bool;
         var stripAfterObfuscation =
-            attribute.NamedValues!.GetValueOrDefault(nameof(ObfuscateAssemblyAttribute.StripAfterObfuscation),
+            namedValues.GetValueOrDefault(nameof(ObfuscateAssemblyAttribute.StripAfterObfuscation),
                 defaultValue: true);
         model = new ObfuscateAssemblyAttributeData(assemblyIsPrivate, stripAfterObfuscation, attribute.Attribute);
         return true;
diff --git a/src/BitMono.Core/Resolvers/ObfuscationAttributeResolver.cs b/src/BitMono.Core/Resolvers/ObfuscationAttributeResolver.cs
@@ -1,8 +1,6 @@
 ﻿namespace BitMono.Core.Resolvers;
 
-[SuppressMessage("ReSharper", "InvertIf")]
-[SuppressMessage("ReSharper", "ForCanBeConvertedToForeach")]
-public class ObfuscationAttributeResolver : AttributeResolver<ObfuscationAttributeData>
+public class ObfuscationAttributeResolver : AttributeResolver<IReadOnlyList<ObfuscationAttributeData>>
 {
     private readonly ObfuscationSettings _obfuscationSettings;
     private readonly string _attributeNamespace;
@@ -11,11 +9,11 @@ public class ObfuscationAttributeResolver : AttributeResolver<ObfuscationAttribu
     public ObfuscationAttributeResolver(IOptions<ObfuscationSettings> configuration)
     {
         _obfuscationSettings = configuration.Value;
-        _attributeNamespace = typeof(ObfuscationAttribute).Namespace;
+        _attributeNamespace = typeof(ObfuscationAttribute).Namespace!;
         _attributeName = nameof(ObfuscationAttribute);
     }
 
-    public override bool Resolve(string? featureName, IHasCustomAttribute from, out ObfuscationAttributeData? model)
+    public override bool Resolve(string? featureName, IHasCustomAttribute from, [NotNullWhen(true)] out IReadOnlyList<ObfuscationAttributeData>? model)
     {
         model = null;
         if (_obfuscationSettings.ObfuscationAttributeObfuscationExclude == false)
@@ -28,37 +26,43 @@ public override bool Resolve(string? featureName, IHasCustomAttribute from, out
             return false;
         }
 
-        for (var i = 0; i < attributesResolve!.Count; i++)
+        var attributes = new List<ObfuscationAttributeData>();
+        foreach (var attribute in attributesResolve)
         {
-            var attribute = attributesResolve[i];
-            if (attribute.NamedValues?.TryGetTypedValue(nameof(ObfuscationAttribute.Feature), out string? feature) == true)
+            var namedValues = attribute.NamedValues;
+            if (namedValues == null)
             {
-                if (feature!.Equals(featureName, StringComparison.OrdinalIgnoreCase))
-                {
-                    var exclude =
-                        attribute.NamedValues.GetValueOrDefault(nameof(ObfuscationAttribute.Exclude),
-                            defaultValue: true);
-                    var applyToMembers =
-                        attribute.NamedValues.GetValueOrDefault(nameof(ObfuscationAttribute.Exclude),
-                            defaultValue: true);
-                    var stripAfterObfuscation =
-                        attribute.NamedValues.GetValueOrDefault(nameof(ObfuscationAttribute.StripAfterObfuscation),
-                            defaultValue: true);
-                    if (exclude)
-                    {
-                        model = new ObfuscationAttributeData
-                        {
-                            Exclude = exclude,
-                            ApplyToMembers = applyToMembers,
-                            StripAfterObfuscation = stripAfterObfuscation,
-                            Feature = feature,
-                            CustomAttribute = attribute.Attribute
-                        };
-                        return true;
-                    }
-                }
+                continue;
             }
+            if (namedValues.TryGetTypedValue(nameof(ObfuscationAttribute.Feature), out string? feature) == false)
+            {
+                continue;
+            }
+            if (feature.Equals(featureName, StringComparison.OrdinalIgnoreCase) == false)
+            {
+                continue;
+            }
+
+            var exclude =
+                namedValues.GetValueOrDefault(nameof(ObfuscationAttribute.Exclude),
+                    defaultValue: true);
+            var applyToMembers =
+                namedValues.GetValueOrDefault(nameof(ObfuscationAttribute.Exclude),
+                    defaultValue: true);
+            var stripAfterObfuscation =
+                namedValues.GetValueOrDefault(nameof(ObfuscationAttribute.StripAfterObfuscation),
+                    defaultValue: true);
+
+            attributes.Add(new ObfuscationAttributeData
+            {
+                Exclude = exclude,
+                ApplyToMembers = applyToMembers,
+                StripAfterObfuscation = stripAfterObfuscation,
+                Feature = feature,
+                CustomAttribute = attribute.Attribute
+            });
         }
-        return false;
+        model = attributes;
+        return true;
     }
 }
diff --git a/src/BitMono.Core/Resolvers/SafeToMakeChangesMemberResolver.cs b/src/BitMono.Core/Resolvers/SafeToMakeChangesMemberResolver.cs
@@ -1,7 +1,5 @@
 ﻿namespace BitMono.Core.Resolvers;
 
-[UsedImplicitly]
-[SuppressMessage("ReSharper", "ConvertIfStatementToReturnStatement")]
 public class SafeToMakeChangesMemberResolver : IMemberResolver
 {
     private readonly ObfuscationAttributeResolver _obfuscationAttributeResolver;
@@ -29,19 +27,15 @@ public bool Resolve(IProtection protection, IMetadataMember member)
         if (member is IHasCustomAttribute customAttribute)
         {
             var feature = protection.GetName();
-            if (_obfuscationAttributeResolver.Resolve(feature, customAttribute, out var obfuscationAttributeData))
+            if (_obfuscationAttributeResolver.Resolve(feature, customAttribute, out var obfuscationAttributes)
+                && obfuscationAttributes.Any(x => x.Exclude))
             {
-                if (obfuscationAttributeData!.Exclude)
-                {
-                    return false;
-                }
+                return false;
             }
-            if (_obfuscateAssemblyAttributeResolver.Resolve(null, customAttribute, out var obfuscateAssemblyAttributeData))
+            if (_obfuscateAssemblyAttributeResolver.Resolve(null, customAttribute, out var obfuscateAssemblyAttributeData)
+                && obfuscateAssemblyAttributeData!.AssemblyIsPrivate)
             {
-                if (obfuscateAssemblyAttributeData!.AssemblyIsPrivate)
-                {
-                    return false;
-                }
+                return false;
             }
             if (_criticalAttributeResolver.Resolve(feature, customAttribute))
             {
diff --git a/src/BitMono.Host/protections.json b/src/BitMono.Host/protections.json
@@ -2,7 +2,7 @@
   "Protections": [
     {
       "Name": "AntiILdasm",
-      "Enabled": true
+      "Enabled": false
     },
     {
       "Name": "AntiDe4dot",
diff --git a/src/BitMono.Obfuscation/BitMonoObfuscator.cs b/src/BitMono.Obfuscation/BitMonoObfuscator.cs
@@ -232,16 +232,14 @@ private bool OptimizeMacros()
         }
         return true;
     }
-    private bool StripObfuscationAttributes()
+    private void StripObfuscationAttributes()
     {
         if (_obfuscationSettings.StripObfuscationAttributes == false)
         {
-            _logger.Information("Obfuscation attributes stripping is disabled (it's ok)");
-            return true;
+            return;
         }
         var obfuscationAttributesStrip = _obfuscationAttributesStripper.Strip(_context, _protectionsSort!);
         _obfuscationAttributesStripNotifier.Notify(obfuscationAttributesStrip);
-        return true;
     }
     private bool CreatePEImage()
     {
diff --git a/src/BitMono.Obfuscation/Notifiers/ObfuscationAttributesStripNotifier.cs b/src/BitMono.Obfuscation/Notifiers/ObfuscationAttributesStripNotifier.cs
@@ -13,22 +13,22 @@ public void Notify(ObfuscationAttributesStrip obfuscationAttributesStrip)
     {
         if (obfuscationAttributesStrip.ObfuscationAttributesSuccessStrip.IsEmpty() == false)
         {
-            _logger.Information("Successfully stripped {0} obfuscation attribute(s)!",
+            _logger.Information("Successfully stripped {0} obfuscation attribute(s)",
                 obfuscationAttributesStrip.ObfuscationAttributesSuccessStrip.Count);
         }
         if (obfuscationAttributesStrip.ObfuscateAssemblyAttributesSuccessStrip.IsEmpty() == false)
         {
-            _logger.Information("Successfully stripped {0} assembly obfuscation attribute(s)!",
+            _logger.Information("Successfully stripped {0} assembly obfuscation attribute(s)",
                 obfuscationAttributesStrip.ObfuscateAssemblyAttributesSuccessStrip.Count);
         }
         if (obfuscationAttributesStrip.ObfuscationAttributesFailStrip.IsEmpty() == false)
         {
-            _logger.Information("Failed to strip {0} assembly obfuscation attribute(s)!",
+            _logger.Information("Failed to strip {0} assembly obfuscation attribute(s)",
                 obfuscationAttributesStrip.ObfuscationAttributesFailStrip.Count);
         }
         if (obfuscationAttributesStrip.ObfuscateAssemblyAttributesFailStrip.IsEmpty() == false)
         {
-            _logger.Information("Failed to strip {0} obfuscation attribute(s)!",
+            _logger.Information("Failed to strip {0} obfuscation attribute(s)",
                 obfuscationAttributesStrip.ObfuscateAssemblyAttributesFailStrip.Count);
         }
     }
diff --git a/src/BitMono.Obfuscation/Stripping/ObfuscationAttributesStripper.cs b/src/BitMono.Obfuscation/Stripping/ObfuscationAttributesStripper.cs
diff --git a/src/BitMono.Protections/BitDecompiler.cs b/src/BitMono.Protections/BitDecompiler.cs
diff --git a/src/BitMono.Shared/BitMono.Shared.csproj b/src/BitMono.Shared/BitMono.Shared.csproj

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`namespace BitMono.API.Resolvers;`
`2`	`2`
	`3`	`+[UsedImplicitly(ImplicitUseTargetFlags.WithInheritors)]`
`3`	`4`	`public interface IMemberResolver`
`4`	`5`	`{`
`5`	`6`	`bool Resolve(IProtection protection, IMetadataMember member);`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`namespace BitMono.Core.Analyzing;`
`2`	`2`
`3`		`-[UsedImplicitly]`
`4`	`3`	`public class CriticalMethodsCriticalAnalyzer : ICriticalAnalyzer<MethodDefinition>`
`5`	`4`	`{`
`6`	`5`	`private readonly CriticalsSettings _criticalsSettings;`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`namespace BitMono.Core.Contexts;`
`2`	`2`
`3`		`-[SuppressMessage("ReSharper", "UnusedAutoPropertyAccessor.Global")]`
`4`	`3`	`public class StarterContext`
`5`	`4`	`{`
`6`	`5`	`#pragma warning disable CS8618`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ public static bool GetValueOrDefault(this Dictionary<string, object> source, str`
`11`	`11`	`}`
`12`	`12`	`return value;`
`13`	`13`	`}`
`14`		`- public static bool TryGetTypedValue<TKey, TValue, TActual>(this IDictionary<TKey, TValue> source, TKey key, out TActual? value)`
	`14`	`+ public static bool TryGetTypedValue<TKey, TValue, TActual>(this IDictionary<TKey, TValue> source, TKey key, [NotNullWhen(true)] out TActual? value)`
`15`	`15`	`where TActual : TValue`
`16`	`16`	`{`
`17`	`17`	`if (source.TryGetValue(key, out var tempValue))`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,8 @@`
`2`	`2`
`3`	`3`	`public static class AttemptAttributeResolver`
`4`	`4`	`{`
`5`		`- public static bool TryResolve(IHasCustomAttribute from, string @namespace, string name, out List<CustomAttributeResolve>? attributesResolve)`
	`5`	`+ public static bool TryResolve(IHasCustomAttribute from, string @namespace, string name,`
	`6`	`+ [NotNullWhen(true)] out List<CustomAttributeResolve>? attributesResolve)`
`6`	`7`	`{`
`7`	`8`	`attributesResolve = CustomAttributeResolver.Resolve(from, @namespace, name);`
`8`	`9`	`return attributesResolve.IsNullOrEmpty() == false;`
Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`public class AttributeResolver<TModel> : IAttributeResolver<TModel> where TModel : class`
`4`	`4`	`{`
`5`		`- public virtual bool Resolve(string? featureName, IHasCustomAttribute from, out TModel? model)`
	`5`	`+ public virtual bool Resolve(string? featureName, IHasCustomAttribute from, [NotNullWhen(true)] out TModel? model)`
`6`	`6`	`{`
`7`	`7`	`model = default;`
`8`	`8`	`return false;`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,5 @@`
`1`	`1`	`namespace BitMono.Core.Resolvers;`
`2`	`2`
`3`		`-[UsedImplicitly]`
`4`		`-[SuppressMessage("ReSharper", "InvertIf")]`
`5`		`-[SuppressMessage("ReSharper", "ForCanBeConvertedToForeach")]`
`6`	`3`	`public class CriticalAttributeResolver : AttributeResolver<CustomAttributeResolve>`
`7`	`4`	`{`
`8`	`5`	`private readonly CriticalsSettings _criticalsSettings;`
`@@ -13,7 +10,7 @@ public CriticalAttributeResolver(IOptions<CriticalsSettings> criticals)`
`13`	`10`	`}`
`14`	`11`
`15`	`12`	`public override bool Resolve(string? feature, IHasCustomAttribute from,`
`16`		`- out CustomAttributeResolve? attributeResolve)`
	`13`	`+ [NotNullWhen(true)] out CustomAttributeResolve? attributeResolve)`
`17`	`14`	`{`
`18`	`15`	`attributeResolve = null;`
`19`	`16`	`if (_criticalsSettings.UseCriticalAttributes == false)`
`@@ -22,17 +19,17 @@ public override bool Resolve(string? feature, IHasCustomAttribute from,`
`22`	`19`	`}`
`23`	`20`
`24`	`21`	`var criticalAttributes = _criticalsSettings.CriticalAttributes;`
`25`		`- for (var i = 0; i < criticalAttributes.Count; i++)`
	`22`	`+ foreach (var criticalAttribute in criticalAttributes)`
`26`	`23`	`{`
`27`		`- var criticalAttribute = criticalAttributes[i];`
`28`	`24`	`if (AttemptAttributeResolver.TryResolve(from, criticalAttribute.Namespace, criticalAttribute.Name,`
`29`		`- out var attributesResolve))`
	`25`	`+ out var attributesResolve) == false)`
`30`	`26`	`{`
`31`		`- attributeResolve = attributesResolve!.First();`
`32`		`- return true;`
	`27`	`+ continue;`
`33`	`28`	`}`
`34`		`- }`
`35`	`29`
	`30`	`+ attributeResolve = attributesResolve.First();`
	`31`	`+ return true;`
	`32`	`+ }`
`36`	`33`	`return false;`
`37`	`34`	`}`
`38`	`35`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,5 @@`
`1`	`1`	`namespace BitMono.Core.Resolvers;`
`2`	`2`
`3`		`-[UsedImplicitly]`
`4`		`-[SuppressMessage("ReSharper", "InvertIf")]`
`5`	`3`	`public class DoNotResolveMemberResolver : IMemberResolver`
`6`	`4`	`{`
`7`	`5`	`private readonly RuntimeCriticalAnalyzer _runtimeCriticalAnalyzer;`