BenMorris/NetArchTest#100 - add rules: AreStateless, BeStateless

Author: NeVeSpl

src/NetArchTest.Rules/Assemblies/TypeContainer.cs

@@ -13,7 +13,7 @@ internal sealed class TypeContainer : IType
         [DebuggerBrowsable(DebuggerBrowsableState.Never)]
         private readonly Lazy<Type> _reflactionType;
         [DebuggerBrowsable(DebuggerBrowsableState.Never)]
-        private readonly Lazy<string> _filePath;
+        private readonly Lazy<string> _sourceFilePath;
 
 
         internal TypeContainer(TypeDefinition monoTypeDefinition, string explanation)
@@ -30,7 +30,7 @@ internal TypeContainer(TypeDefinition monoTypeDefinition, string explanation)
                 }
                 return null;
             });
-            _filePath = new Lazy<string>(() => _monoTypeDefinition.GetFilePath());
+            _sourceFilePath = new Lazy<string>(() => _monoTypeDefinition.GetFilePath());
             Explanation = explanation;
         }
 
@@ -39,7 +39,7 @@ internal TypeContainer(TypeDefinition monoTypeDefinition, string explanation)
         public string FullName => _monoTypeDefinition.FullName;     
         public string Name => _monoTypeDefinition.Name;
         public string Explanation { get; }
-        public string FilePath => _filePath.Value;
+        public string SourceFilePath => _sourceFilePath.Value;
 
 
         public static implicit operator System.Type(TypeContainer type)

src/NetArchTest.Rules/Assemblies/TypeSpec.cs

@@ -7,7 +7,7 @@ namespace NetArchTest.Assemblies
     [DebuggerDisplay("TypeSpec: {FullName}")]
     internal sealed class TypeSpec
     {
-        private readonly Lazy<string> _filePath;
+        private readonly Lazy<string> _sourceFilePath;
 
         public TypeDefinition Definition { get; }
         public string FullName => Definition.FullName;
@@ -16,13 +16,13 @@ internal sealed class TypeSpec
         // Can be use by any function
         internal bool IsPassing { get; set; }
         public string Explanation { get; set; }
-        public string FilePath => _filePath.Value;
+        public string SourceFilePath => _sourceFilePath.Value;
 
 
         public TypeSpec(TypeDefinition definition)
         {
             Definition = definition;
-            _filePath = new Lazy<string>(() => Definition.GetFilePath());
+            _sourceFilePath = new Lazy<string>(() => Definition.GetFilePath());
         }
 
 

src/NetArchTest.Rules/Condition_Special.cs

@@ -34,6 +34,17 @@ public ConditionList BeImmutableExternally()
             return CreateConditionList();
         }
 
+
+        /// <summary>
+        /// Selects types that are stateless, they do not have instance state
+        /// </summary>
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public ConditionList BeStateless()
+        {
+            AddFunctionCall(x => FunctionDelegates.BeStateless(x, true));
+            return CreateConditionList();
+        }
+
         /// <summary>
         /// Selects types according to whether they have nullable members.
         /// </summary>

src/NetArchTest.Rules/Extensions/Mono.Cecil/TypeDefinitionExtensions.cs

@@ -66,7 +66,7 @@ private static IEnumerable<TypeDefinition> EnumerateBaseClasses(this TypeDefinit
         /// <param name="typeDefinition">The type definition to convert.</param>
         /// <returns>The equivalent <see cref="Type"/> object instance.</returns>
         public static Type ToType(this TypeDefinition typeDefinition)
-        {            
+        {
             var fullName = RuntimeNameToReflectionName(typeDefinition.FullName);
             return Type.GetType(string.Concat(fullName, ", ", typeDefinition.Module.Assembly.FullName), true);
         }
@@ -105,7 +105,7 @@ public static bool IsImmutableExternally(this TypeDefinition typeDefinition)
         }
 
 
-      
+
         public static bool OnlyHasNullableMembers(this TypeDefinition typeDefinition)
         {
             var propertiesAreNullable = typeDefinition.Properties.All(p => p.IsNullable());
@@ -159,7 +159,7 @@ public static string GetFullName(this TypeDefinition typeDefinition)
             return typeDefinition.FullName.RemoveGenericPart();
         }
 
-       
+
 
 
         public static bool IsDelegate(this TypeDefinition typeDefinition)
@@ -174,7 +174,7 @@ public static bool IsStruct(this TypeDefinition typeDefinition)
 
 
         public static string GetFilePath(this TypeDefinition typeDefinition)
-        {            
+        {
             if (typeDefinition.HasMethods)
             {
                 foreach (var method in typeDefinition.Methods)
@@ -190,5 +190,22 @@ public static string GetFilePath(this TypeDefinition typeDefinition)
             }
             return null;
         }
+
+        public static bool IsStateless(this TypeDefinition type)
+        {
+            // Check if the type has any instance fields
+            if (type.HasFields)
+            {
+                foreach (var field in type.Fields)
+                {
+                    // If the field is not static, the type is not stateless
+                    if (!field.IsStatic)
+                    {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        }
     }
 }

src/NetArchTest.Rules/Functions/FunctionDelegates_Special.cs

@@ -54,5 +54,18 @@ internal static IEnumerable<TypeSpec> OnlyHaveNonNullableMembers(IEnumerable<Typ
                 return input.Where(c => !c.Definition.OnlyHasNonNullableMembers());
             }
         }
+
+
+        internal static IEnumerable<TypeSpec> BeStateless(IEnumerable<TypeSpec> input, bool condition)
+        {
+            if (condition)
+            {
+                return input.Where(c => c.Definition.IsStateless());
+            }
+            else
+            {
+                return input.Where(c => !c.Definition.IsStateless());
+            }
+        }
     }
 }

src/NetArchTest.Rules/IType.cs

@@ -37,6 +37,6 @@ public interface IType
         /// <remarks>
         /// This property may be null if assembly debug symbols (PDB) were not loaded correctly or given type does not have any instructions inside.
         /// </remarks>
-        string FilePath { get; }
+        string SourceFilePath { get; }
     }
 }

src/NetArchTest.Rules/Predicate_Special.cs

@@ -34,6 +34,16 @@ public PredicateList AreImmutableExternally()
             return CreatePredicateList();
         }
 
+        /// <summary>
+        /// Selects types that are stateless, they do not have instance state
+        /// </summary>
+        /// <returns>An updated set of conditions that can be applied to a list of types.</returns>
+        public PredicateList AreStateless()
+        {
+            AddFunctionCall(x => FunctionDelegates.BeStateless(x, true));
+            return CreatePredicateList();
+        }
+
         /// <summary>
         /// Selects types that have only nullable members.
         /// </summary>

test/NetArchTest.Rules.UnitTests/ConditionTests_Special.cs

@@ -1,7 +1,10 @@
-using System.Reflection;
+using System.Linq;
+using System.Reflection;
 using NetArchTest.Rules;
 using NetArchTest.TestStructure.NameMatching.Namespace1;
+using NetArchTest.TestStructure.Stateless;
 using Xunit;
+using static NetArchTest.Utils;
 
 namespace NetArchTest.UnitTests
 {
@@ -54,6 +57,22 @@ public void BeImmutableExternally()
             Assert.True(result.IsSuccessful);
         }
 
+
+        [Fact(DisplayName = "AreStateless")]
+        public void AreStateless()
+        {
+            var result = Types
+                .InAssembly(Assembly.GetAssembly(typeof(StatelessClass_StaticField)))
+                .That()
+                .ResideInNamespace(namespaceof<StatelessClass_StaticField>())
+                .And()
+                .HaveNameStartingWith("Stateless")
+                .Should()
+                .BeStateless().GetResult();
+
+            Assert.True(result.IsSuccessful);
+        }
+
         [Fact(DisplayName = "OnlyHaveNullableMembers")]
         public void OnlyHaveNullableMembers()
         {

test/NetArchTest.Rules.UnitTests/PredicateTests_Special.cs

@@ -5,7 +5,9 @@
 using NetArchTest.TestStructure.Mutability;
 using NetArchTest.TestStructure.NameMatching.Namespace1;
 using NetArchTest.TestStructure.Nullable;
+using NetArchTest.TestStructure.Stateless;
 using Xunit;
+using static NetArchTest.Utils;
 
 namespace NetArchTest.UnitTests
 {
@@ -70,6 +72,23 @@ public void AreImmutableExternally()
             Assert.Contains<Type>(typeof(MutableClass_PrivateField), result);           
         }
 
+        [Fact(DisplayName = "AreStateless")]
+        public void AreStateless()
+        {
+            var result = Types
+                .InAssembly(Assembly.GetAssembly(typeof(StatelessClass_StaticField)))
+                .That()
+                .ResideInNamespace(namespaceof<StatelessClass_StaticField>())
+                .And()
+                .AreStateless().GetReflectionTypes();
+
+            Assert.Equal(4, result.Count());
+            Assert.Contains<Type>(typeof(StatelessClass_StaticField), result);
+            Assert.Contains<Type>(typeof(StatelessClass_ConstField), result);
+            Assert.Contains<Type>(typeof(StatelessClass_StaticReadonlyField), result);
+            Assert.Contains<Type>(typeof(StatelessClass_Prop), result);
+        }
+
         [Fact(DisplayName = "OnlyHaveNullableMembers")]
         public void OnlyHaveNullableMembers()
         {

test/NetArchTest.TestStructure/Stateless/StatefulTypes.cs

@@ -0,0 +1,20 @@
+namespace NetArchTest.TestStructure.Stateless
+{
+    internal class StatefulClass_Field
+    {
+        public int field;
+    }
+    internal record class StatefulRecordClass(int Prop);
+
+    internal record struct StatefulRecordStruct(int Prop);
+
+    internal class StatefulClass_Prop
+    {
+        public int Prop { get; set; }
+    }
+
+    internal class StatefulClass_ReadonlyField
+    {
+        public readonly int field = 7;
+    }
+}