Remove redundant private modifiers (#670)

hazzik · web-flow · commit 3931d9680e97 · 2024-04-02T04:14:24.000+02:00
+semver:patch
diff --git a/src/FluentNHibernate.Testing/Utils/ExtensionsTests.cs b/src/FluentNHibernate.Testing/Utils/ExtensionsTests.cs
@@ -13,12 +13,12 @@ public PublicConstructor() { }
 
     class PrivateConstructor
     {
-        private PrivateConstructor() { }
+        PrivateConstructor() { }
     }
 
     class ConstructorWithArguments
     {
-        private ConstructorWithArguments(int number) { }
+        ConstructorWithArguments(int number) { }
     }
 
     [Test]
diff --git a/src/FluentNHibernate/Cfg/Db/PersistenceConfiguration.cs b/src/FluentNHibernate/Cfg/Db/PersistenceConfiguration.cs
@@ -37,11 +37,11 @@ public abstract class PersistenceConfiguration<TThisConfiguration, TConnectionSt
     protected const string AdoNetBatchSizeKey = NHibEnvironment.BatchSize;
     protected const string CurrentSessionContextClassKey = "current_session_context_class";
 
-    private readonly Dictionary<string, string> values = new Dictionary<string, string>();
+    readonly Dictionary<string, string> values = new Dictionary<string, string>();
 
-    private bool nextBoolSettingValue = true;
-    private readonly TConnectionString connectionString;
-    private readonly CacheSettingsBuilder cache = new CacheSettingsBuilder();
+    bool nextBoolSettingValue = true;
+    readonly TConnectionString connectionString;
+    readonly CacheSettingsBuilder cache = new CacheSettingsBuilder();
 
     protected PersistenceConfiguration()
     {
@@ -71,7 +71,7 @@ static IEnumerable<string> OverridenDefaults(IDictionary<string,string> settings
             yield return ConnectionProviderKey;
     }
 
-    private static IEnumerable<string> KeysToPreserve(NHibConfiguration nhibernateConfig, IDictionary<string, string> settings)
+    static IEnumerable<string> KeysToPreserve(NHibConfiguration nhibernateConfig, IDictionary<string, string> settings)
     {
         var @default = new NHibConfiguration();
         return nhibernateConfig.Properties
diff --git a/src/FluentNHibernate/Mapping/AnyPart.cs b/src/FluentNHibernate/Mapping/AnyPart.cs
@@ -15,13 +15,13 @@ namespace FluentNHibernate.Mapping;
 /// </summary>
 public class AnyPart<T> : IAnyMappingProvider
 {
-    private readonly AttributeStore attributes = new AttributeStore();
-    private readonly Type entity;
-    private readonly Member member;
-    private readonly IList<string> typeColumns = new List<string>();
-    private readonly IList<string> identifierColumns = new List<string>();
-    private readonly IList<MetaValueMapping> metaValues = new List<MetaValueMapping>();
-    private bool nextBool = true;
+    readonly AttributeStore attributes = new AttributeStore();
+    readonly Type entity;
+    readonly Member member;
+    readonly IList<string> typeColumns = new List<string>();
+    readonly IList<string> identifierColumns = new List<string>();
+    readonly IList<MetaValueMapping> metaValues = new List<MetaValueMapping>();
+    bool nextBool = true;
     bool idTypeSet;
 
     public AnyPart(Type entity, Member member)
diff --git a/src/FluentNHibernate/Mapping/PropertyPart.cs b/src/FluentNHibernate/Mapping/PropertyPart.cs
@@ -15,7 +15,7 @@ public class PropertyPart : IPropertyMappingProvider
     readonly AttributeStore attributes = new AttributeStore();
     readonly AttributeStore columnAttributes = new AttributeStore();
 
-    private bool nextBool = true;
+    bool nextBool = true;
 
     public PropertyPart(Member member, Type parentType)
     {
@@ -201,7 +201,7 @@ public PropertyPart CustomType(Func<Type, Type> typeFunc)
         return CustomType(TypeMapping.GetTypeString(type));
     }
 
-    private void AddColumnsFromCompositeUserType(Type compositeUserType)
+    void AddColumnsFromCompositeUserType(Type compositeUserType)
     {
         var inst = (ICompositeUserType)Activator.CreateInstance(compositeUserType);
 
diff --git a/src/FluentNHibernate/Mapping/ReferenceComponentPart.cs b/src/FluentNHibernate/Mapping/ReferenceComponentPart.cs
@@ -12,7 +12,7 @@ namespace FluentNHibernate.Mapping;
 /// <typeparam name="T">Component type</typeparam>
 public class ReferenceComponentPart<T>(Member property, Type containingEntityType) : IReferenceComponentMappingProvider
 {
-    private string columnPrefix;
+    string columnPrefix;
 
     /// <summary>
     /// Sets the prefix for any columns defined within the component. To refer to the property
diff --git a/src/FluentNHibernate/Mapping/ToManyBase.cs b/src/FluentNHibernate/Mapping/ToManyBase.cs
@@ -390,7 +390,7 @@ public T AsIndexedCollection<TIndex>(string indexColumn, Action<IndexPart> custo
         return (T)this;
     }
 
-    private void CreateIndexMapping(Action<IndexPart> customIndex)
+    void CreateIndexMapping(Action<IndexPart> customIndex)
     {
         var indexPart = new IndexPart(typeof(T));
 
@@ -401,7 +401,7 @@ private void CreateIndexMapping(Action<IndexPart> customIndex)
 #pragma warning restore 612,618
     }
 
-    private void CreateListIndexMapping(Action<ListIndexPart> customIndex)
+    void CreateListIndexMapping(Action<ListIndexPart> customIndex)
     {
         indexMapping = new IndexMapping();
         var builder = new ListIndexPart(indexMapping);
@@ -737,7 +737,7 @@ protected virtual CollectionMapping GetCollectionMapping()
         return mapping;
     }
 
-    private string GetDefaultName()
+    string GetDefaultName()
     {
         if (member.IsMethod)
         {
diff --git a/src/FluentNHibernate/PersistenceModel.cs b/src/FluentNHibernate/PersistenceModel.cs
@@ -29,11 +29,12 @@ public class PersistenceModel
     {
         new ComponentMapComponentReferenceResolver()
     };
-    private readonly IList<IMappingModelVisitor> visitors = new List<IMappingModelVisitor>();
+
+    readonly IList<IMappingModelVisitor> visitors = new List<IMappingModelVisitor>();
     public IConventionFinder Conventions { get; }
     public bool MergeMappings { get; set; }
-    private IEnumerable<HibernateMapping> compiledMappings;
-    private ValidationVisitor validationVisitor;
+    IEnumerable<HibernateMapping> compiledMappings;
+    ValidationVisitor validationVisitor;
     public PairBiDirectionalManyToManySidesDelegate BiDirectionalManyToManyPairer { get; set; }
 
     IDiagnosticMessageDispatcher diagnosticDispatcher = new DefaultDiagnosticMessageDispatcher();
@@ -86,7 +87,7 @@ public void AddMappingsFromSource(ITypeSource source)
         log.LoadedFluentMappingsFromSource(source);
     }
 
-    private static Assembly FindTheCallingAssembly()
+    static Assembly FindTheCallingAssembly()
     {
         StackTrace trace = new StackTrace(false);
 
@@ -150,7 +151,7 @@ public void Add(Type type)
             throw new InvalidOperationException("Unsupported mapping type '" + type.FullName + "'");
     }
 
-    private bool IsMappingOf<T>(Type type)
+    bool IsMappingOf<T>(Type type)
     {
         return !type.IsGenericType && typeof(T).IsAssignableFrom(type);
     }
@@ -171,7 +172,7 @@ public virtual IEnumerable<HibernateMapping> BuildMappings()
         return hbms;
     }
 
-    private void BuildSeparateMappings(Action<HibernateMapping> add)
+    void BuildSeparateMappings(Action<HibernateMapping> add)
     {
         foreach (var classMap in classProviders)
         {
@@ -190,7 +191,7 @@ private void BuildSeparateMappings(Action<HibernateMapping> add)
         }
     }
 
-    private void BuildSingleMapping(Action<HibernateMapping> add)
+    void BuildSingleMapping(Action<HibernateMapping> add)
     {
         var hbm = new HibernateMapping();
 
@@ -207,13 +208,13 @@ private void BuildSingleMapping(Action<HibernateMapping> add)
             add(hbm);
     }
 
-    private void ApplyVisitors(IEnumerable<HibernateMapping> mappings)
+    void ApplyVisitors(IEnumerable<HibernateMapping> mappings)
     {
         foreach (var visitor in visitors)
             visitor.Visit(mappings);
     }
 
-    private void EnsureMappingsBuilt()
+    void EnsureMappingsBuilt()
     {
         if (compiledMappings is not null) return;
 
@@ -225,7 +226,7 @@ protected virtual string GetMappingFileName()
         return "FluentMappings.hbm.xml";
     }
 
-    private string DetermineMappingFileName(HibernateMapping mapping)
+    string DetermineMappingFileName(HibernateMapping mapping)
     {
         if (MergeMappings)
             return GetMappingFileName();
@@ -246,7 +247,7 @@ public void WriteMappingsTo(TextWriter writer)
         WriteMappingsTo( _ => new XmlTextWriter(writer), false);
     }
 
-    private void WriteMappingsTo(Func<HibernateMapping, XmlTextWriter> writerBuilder, bool shouldDispose)
+    void WriteMappingsTo(Func<HibernateMapping, XmlTextWriter> writerBuilder, bool shouldDispose)
     {
         EnsureMappingsBuilt();
 
diff --git a/src/FluentNHibernate/SessionSource.cs b/src/FluentNHibernate/SessionSource.cs
@@ -19,7 +19,7 @@ public interface ISessionSource
 
 public class SessionSource : ISessionSource
 {
-    private Dialect dialect;
+    Dialect dialect;
     public Configuration Configuration { get; private set; }
     public ISessionFactory SessionFactory { get; private set; }
 
diff --git a/src/FluentNHibernate/Testing/PersistenceSpecification.cs b/src/FluentNHibernate/Testing/PersistenceSpecification.cs
@@ -9,9 +9,9 @@ namespace FluentNHibernate.Testing;
 public class PersistenceSpecification<T>
 {
     protected readonly List<Property<T>> allProperties = new List<Property<T>>();
-    private readonly ISession currentSession;
-    private readonly IEqualityComparer entityEqualityComparer;
-    private readonly bool hasExistingTransaction;
+    readonly ISession currentSession;
+    readonly IEqualityComparer entityEqualityComparer;
+    readonly bool hasExistingTransaction;
 
     public PersistenceSpecification(ISessionSource source)
         : this(source.CreateSession())
diff --git a/src/FluentNHibernate/Testing/Values/List.cs b/src/FluentNHibernate/Testing/Values/List.cs
@@ -9,7 +9,7 @@ namespace FluentNHibernate.Testing.Values;
 public class List<T, TListElement>(Accessor property, IEnumerable<TListElement> value)
     : Property<T, IEnumerable<TListElement>>(property, value)
 {
-    private Action<T, Accessor, IEnumerable<TListElement>> _valueSetter;
+    Action<T, Accessor, IEnumerable<TListElement>> _valueSetter;
 
     public override Action<T, Accessor, IEnumerable<TListElement>> ValueSetter
     {
@@ -56,7 +56,7 @@ public override void CheckValue(object target)
         AssertGenericListMatches(actual, Expected);
     }
 
-    private void AssertGenericListMatches(IEnumerable actualEnumerable, IEnumerable<TListElement> expectedEnumerable)
+    void AssertGenericListMatches(IEnumerable actualEnumerable, IEnumerable<TListElement> expectedEnumerable)
     {
         if (actualEnumerable is null)
         {
diff --git a/src/FluentNHibernate/Testing/Values/Property.cs b/src/FluentNHibernate/Testing/Values/Property.cs
@@ -16,8 +16,8 @@ public virtual void HasRegistered(PersistenceSpecification<T> specification)
 
 public class Property<T, TProperty>(Accessor property, TProperty value) : Property<T>
 {
-    private static readonly Action<T, Accessor, TProperty> DefaultValueSetter = (target, propertyAccessor, value) => propertyAccessor.SetValue (target, value);
-    private Action<T, Accessor, TProperty> _valueSetter;
+    static readonly Action<T, Accessor, TProperty> DefaultValueSetter = (target, propertyAccessor, value) => propertyAccessor.SetValue (target, value);
+    Action<T, Accessor, TProperty> _valueSetter;
 
     public virtual Action<T, Accessor, TProperty> ValueSetter
     {
@@ -69,7 +69,7 @@ public override void CheckValue(object target)
         }
     }
 
-    private string GetInequalityComparisonMessage(object actual)
+    string GetInequalityComparisonMessage(object actual)
     {
         string message;
 
diff --git a/src/FluentNHibernate/Testing/Values/ReferenceBag.cs b/src/FluentNHibernate/Testing/Values/ReferenceBag.cs
@@ -15,7 +15,7 @@ public override void CheckValue(object target)
         AssertGenericListMatches(actual, Expected);
     }
 
-    private void AssertGenericListMatches(IEnumerable actualEnumerable, IEnumerable<TListElement> expectedEnumerable)
+    void AssertGenericListMatches(IEnumerable actualEnumerable, IEnumerable<TListElement> expectedEnumerable)
     {
         if (actualEnumerable is null)
         {

Original file line number	Diff line number	Diff line change
`@@ -13,12 +13,12 @@ public PublicConstructor() { }`
`13`	`13`
`14`	`14`	`class PrivateConstructor`
`15`	`15`	`{`
`16`		`- private PrivateConstructor() { }`
	`16`	`+ PrivateConstructor() { }`
`17`	`17`	`}`
`18`	`18`
`19`	`19`	`class ConstructorWithArguments`
`20`	`20`	`{`
`21`		`- private ConstructorWithArguments(int number) { }`
	`21`	`+ ConstructorWithArguments(int number) { }`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`[Test]`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public class PropertyPart : IPropertyMappingProvider`
`15`	`15`	`readonly AttributeStore attributes = new AttributeStore();`
`16`	`16`	`readonly AttributeStore columnAttributes = new AttributeStore();`
`17`	`17`
`18`		`- private bool nextBool = true;`
	`18`	`+ bool nextBool = true;`
`19`	`19`
`20`	`20`	`public PropertyPart(Member member, Type parentType)`
`21`	`21`	`{`
`@@ -201,7 +201,7 @@ public PropertyPart CustomType(Func<Type, Type> typeFunc)`
`201`	`201`	`return CustomType(TypeMapping.GetTypeString(type));`
`202`	`202`	`}`
`203`	`203`
`204`		`- private void AddColumnsFromCompositeUserType(Type compositeUserType)`
	`204`	`+ void AddColumnsFromCompositeUserType(Type compositeUserType)`
`205`	`205`	`{`
`206`	`206`	`var inst = (ICompositeUserType)Activator.CreateInstance(compositeUserType);`
`207`	`207`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ namespace FluentNHibernate.Mapping;`
`12`	`12`	`/// <typeparam name="T">Component type</typeparam>`
`13`	`13`	`public class ReferenceComponentPart<T>(Member property, Type containingEntityType) : IReferenceComponentMappingProvider`
`14`	`14`	`{`
`15`		`- private string columnPrefix;`
	`15`	`+ string columnPrefix;`
`16`	`16`
`17`	`17`	`/// <summary>`
`18`	`18`	`/// Sets the prefix for any columns defined within the component. To refer to the property`
Original file line number	Diff line number	Diff line change
`@@ -390,7 +390,7 @@ public T AsIndexedCollection<TIndex>(string indexColumn, Action<IndexPart> custo`
`390`	`390`	`return (T)this;`
`391`	`391`	`}`
`392`	`392`
`393`		`- private void CreateIndexMapping(Action<IndexPart> customIndex)`
	`393`	`+ void CreateIndexMapping(Action<IndexPart> customIndex)`
`394`	`394`	`{`
`395`	`395`	`var indexPart = new IndexPart(typeof(T));`
`396`	`396`
`@@ -401,7 +401,7 @@ private void CreateIndexMapping(Action<IndexPart> customIndex)`
`401`	`401`	`#pragma warning restore 612,618`
`402`	`402`	`}`
`403`	`403`
`404`		`- private void CreateListIndexMapping(Action<ListIndexPart> customIndex)`
	`404`	`+ void CreateListIndexMapping(Action<ListIndexPart> customIndex)`
`405`	`405`	`{`
`406`	`406`	`indexMapping = new IndexMapping();`
`407`	`407`	`var builder = new ListIndexPart(indexMapping);`
`@@ -737,7 +737,7 @@ protected virtual CollectionMapping GetCollectionMapping()`
`737`	`737`	`return mapping;`
`738`	`738`	`}`
`739`	`739`
`740`		`- private string GetDefaultName()`
	`740`	`+ string GetDefaultName()`
`741`	`741`	`{`
`742`	`742`	`if (member.IsMethod)`
`743`	`743`	`{`
Original file line number	Diff line number	Diff line change
`@@ -29,11 +29,12 @@ public class PersistenceModel`
`29`	`29`	`{`
`30`	`30`	`new ComponentMapComponentReferenceResolver()`
`31`	`31`	`};`
`32`		`- private readonly IList<IMappingModelVisitor> visitors = new List<IMappingModelVisitor>();`
	`32`	`+`
	`33`	`+ readonly IList<IMappingModelVisitor> visitors = new List<IMappingModelVisitor>();`
`33`	`34`	`public IConventionFinder Conventions { get; }`
`34`	`35`	`public bool MergeMappings { get; set; }`
`35`		`- private IEnumerable<HibernateMapping> compiledMappings;`
`36`		`- private ValidationVisitor validationVisitor;`
	`36`	`+ IEnumerable<HibernateMapping> compiledMappings;`
	`37`	`+ ValidationVisitor validationVisitor;`
`37`	`38`	`public PairBiDirectionalManyToManySidesDelegate BiDirectionalManyToManyPairer { get; set; }`
`38`	`39`
`39`	`40`	`IDiagnosticMessageDispatcher diagnosticDispatcher = new DefaultDiagnosticMessageDispatcher();`
`@@ -86,7 +87,7 @@ public void AddMappingsFromSource(ITypeSource source)`
`86`	`87`	`log.LoadedFluentMappingsFromSource(source);`
`87`	`88`	`}`
`88`	`89`
`89`		`- private static Assembly FindTheCallingAssembly()`
	`90`	`+ static Assembly FindTheCallingAssembly()`
`90`	`91`	`{`
`91`	`92`	`StackTrace trace = new StackTrace(false);`
`92`	`93`
`@@ -150,7 +151,7 @@ public void Add(Type type)`
`150`	`151`	`throw new InvalidOperationException("Unsupported mapping type '" + type.FullName + "'");`
`151`	`152`	`}`
`152`	`153`
`153`		`- private bool IsMappingOf<T>(Type type)`
	`154`	`+ bool IsMappingOf<T>(Type type)`
`154`	`155`	`{`
`155`	`156`	`return !type.IsGenericType && typeof(T).IsAssignableFrom(type);`
`156`	`157`	`}`
`@@ -171,7 +172,7 @@ public virtual IEnumerable<HibernateMapping> BuildMappings()`
`171`	`172`	`return hbms;`
`172`	`173`	`}`
`173`	`174`
`174`		`- private void BuildSeparateMappings(Action<HibernateMapping> add)`
	`175`	`+ void BuildSeparateMappings(Action<HibernateMapping> add)`
`175`	`176`	`{`
`176`	`177`	`foreach (var classMap in classProviders)`
`177`	`178`	`{`
`@@ -190,7 +191,7 @@ private void BuildSeparateMappings(Action<HibernateMapping> add)`
`190`	`191`	`}`
`191`	`192`	`}`
`192`	`193`
`193`		`- private void BuildSingleMapping(Action<HibernateMapping> add)`
	`194`	`+ void BuildSingleMapping(Action<HibernateMapping> add)`
`194`	`195`	`{`
`195`	`196`	`var hbm = new HibernateMapping();`
`196`	`197`
`@@ -207,13 +208,13 @@ private void BuildSingleMapping(Action<HibernateMapping> add)`
`207`	`208`	`add(hbm);`
`208`	`209`	`}`
`209`	`210`
`210`		`- private void ApplyVisitors(IEnumerable<HibernateMapping> mappings)`
	`211`	`+ void ApplyVisitors(IEnumerable<HibernateMapping> mappings)`
`211`	`212`	`{`
`212`	`213`	`foreach (var visitor in visitors)`
`213`	`214`	`visitor.Visit(mappings);`
`214`	`215`	`}`
`215`	`216`
`216`		`- private void EnsureMappingsBuilt()`
	`217`	`+ void EnsureMappingsBuilt()`
`217`	`218`	`{`
`218`	`219`	`if (compiledMappings is not null) return;`
`219`	`220`
`@@ -225,7 +226,7 @@ protected virtual string GetMappingFileName()`
`225`	`226`	`return "FluentMappings.hbm.xml";`
`226`	`227`	`}`
`227`	`228`
`228`		`- private string DetermineMappingFileName(HibernateMapping mapping)`
	`229`	`+ string DetermineMappingFileName(HibernateMapping mapping)`
`229`	`230`	`{`
`230`	`231`	`if (MergeMappings)`
`231`	`232`	`return GetMappingFileName();`
`@@ -246,7 +247,7 @@ public void WriteMappingsTo(TextWriter writer)`
`246`	`247`	`WriteMappingsTo( _ => new XmlTextWriter(writer), false);`
`247`	`248`	`}`
`248`	`249`
`249`		`- private void WriteMappingsTo(Func<HibernateMapping, XmlTextWriter> writerBuilder, bool shouldDispose)`
	`250`	`+ void WriteMappingsTo(Func<HibernateMapping, XmlTextWriter> writerBuilder, bool shouldDispose)`
`250`	`251`	`{`
`251`	`252`	`EnsureMappingsBuilt();`
`252`	`253`
Original file line number	Diff line number	Diff line change
`@@ -19,7 +19,7 @@ public interface ISessionSource`
`19`	`19`
`20`	`20`	`public class SessionSource : ISessionSource`
`21`	`21`	`{`
`22`		`- private Dialect dialect;`
	`22`	`+ Dialect dialect;`
`23`	`23`	`public Configuration Configuration { get; private set; }`
`24`	`24`	`public ISessionFactory SessionFactory { get; private set; }`
`25`	`25`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ namespace FluentNHibernate.Testing.Values;`
`9`	`9`	`public class List<T, TListElement>(Accessor property, IEnumerable<TListElement> value)`
`10`	`10`	`: Property<T, IEnumerable<TListElement>>(property, value)`
`11`	`11`	`{`
`12`		`- private Action<T, Accessor, IEnumerable<TListElement>> _valueSetter;`
	`12`	`+ Action<T, Accessor, IEnumerable<TListElement>> _valueSetter;`
`13`	`13`
`14`	`14`	`public override Action<T, Accessor, IEnumerable<TListElement>> ValueSetter`
`15`	`15`	`{`
`@@ -56,7 +56,7 @@ public override void CheckValue(object target)`
`56`	`56`	`AssertGenericListMatches(actual, Expected);`
`57`	`57`	`}`
`58`	`58`
`59`		`- private void AssertGenericListMatches(IEnumerable actualEnumerable, IEnumerable<TListElement> expectedEnumerable)`
	`59`	`+ void AssertGenericListMatches(IEnumerable actualEnumerable, IEnumerable<TListElement> expectedEnumerable)`
`60`	`60`	`{`
`61`	`61`	`if (actualEnumerable is null)`
`62`	`62`	`{`