dotnet format

kristiker · kristiker · commit 14a7064d652c · 2025-06-05T13:54:39.000+02:00
diff --git a/Datamodel.NET/Arrays.cs b/Datamodel.NET/Arrays.cs
@@ -181,8 +181,8 @@ internal set
                         if (elem.Owner == null)
                         {
                             var importedElement = OwnerDatamodel.ImportElement(elem, Datamodel.ImportRecursionMode.Stubs, Datamodel.ImportOverwriteMode.Stubs);
-                            
-                            if(importedElement is not null)
+
+                            if (importedElement is not null)
                             {
                                 Inner[i] = importedElement;
                             }
@@ -201,8 +201,8 @@ protected override void Insert_Internal(int index, Element item)
                 if (item.Owner == null)
                 {
                     var importedElement = OwnerDatamodel.ImportElement(item, Datamodel.ImportRecursionMode.Recursive, Datamodel.ImportOverwriteMode.Stubs);
-                
-                    if(importedElement is not null)
+
+                    if (importedElement is not null)
                     {
                         item = importedElement;
                     }
diff --git a/Datamodel.NET/AttributeList.cs b/Datamodel.NET/AttributeList.cs
@@ -29,7 +29,7 @@ private ICollection<Attribute> GetPropertyBasedAttributes(bool useSerializationN
             var result = new List<Attribute>();
             foreach (DictionaryEntry entry in PropertyInfos)
             {
-                if(entry.Value is null)
+                if (entry.Value is null)
                 {
                     throw new InvalidDataException("Property value can not be null");
                 }
@@ -135,7 +135,7 @@ public void Add(string key, object? value)
         {
             var attrib = Inner[key];
 
-            if(attrib is null)
+            if (attrib is null)
             {
                 return null;
             }
@@ -269,7 +269,7 @@ public virtual object? this[string name]
                     {
                         // were actually fine with this being null, it will just set the value to null
                         // but need to check so the type check doesn't fail if it is null
-                        if(value != null)
+                        if (value != null)
                         {
                             var valueType = value.GetType();
 
@@ -307,7 +307,7 @@ public virtual object? this[string name]
 
                     return;
                 }
-                
+
                 Attribute? old_attr;
                 Attribute? new_attr;
                 int old_index = -1;
@@ -343,7 +343,7 @@ public AttrKVP this[int index]
             {
                 var attr = (Attribute?)Inner[index];
 
-                if(attr is null)
+                if (attr is null)
                 {
                     throw new InvalidOperationException($"attribute at index {index} doesn't exist");
                 }
@@ -367,7 +367,7 @@ public void RemoveAt(int index)
             {
                 attr = (Attribute?)Inner[index];
 
-                if(attr is not null)
+                if (attr is not null)
                 {
                     attr.Owner = null;
                     Inner.RemoveAt(index);
@@ -571,7 +571,7 @@ public static ValueComparer Default
 
         public new bool Equals(object? x, object? y)
         {
-            if(x is null || y is null)
+            if (x is null || y is null)
             {
                 return false;
             }
diff --git a/Datamodel.NET/Datamodel.ElementList.cs b/Datamodel.NET/Datamodel.ElementList.cs
@@ -219,7 +219,7 @@ public void Trim()
                     {
                         foreach (var elem in this.Except(used).ToArray())
                         {
-                            if(elem != null)
+                            if (elem != null)
                             {
                                 store.Remove(elem.ID);
                                 elem.Owner = null;
@@ -241,7 +241,7 @@ public void Trim()
 
             protected void WalkElemTree(Element? elem, HashSet<Element?> found)
             {
-                if(elem is null)
+                if (elem is null)
                 {
                     return;
                 }
diff --git a/Datamodel.NET/Datamodel.cs b/Datamodel.NET/Datamodel.cs
@@ -167,7 +167,7 @@ private static ICodec GetCodec(string encoding, int encoding_version)
 
             var codecConstructor = codec_type.GetConstructor(Type.EmptyTypes);
 
-            if(codecConstructor is null)
+            if (codecConstructor is null)
             {
                 throw new InvalidOperationException("Failed to get codec constructor.");
             }
@@ -252,7 +252,7 @@ public static Datamodel Load(Stream stream, DeferredMode defer_mode = DeferredMo
         public static Datamodel Load<T>(Stream stream, DeferredMode defer_mode = DeferredMode.Automatic, ReflectionParams? reflectionParams = null)
             where T : Element
         {
-            return Load_Internal<T>(stream,defer_mode, reflectionParams);
+            return Load_Internal<T>(stream, defer_mode, reflectionParams);
         }
 
         /// <summary>
@@ -262,7 +262,7 @@ public static Datamodel Load<T>(Stream stream, DeferredMode defer_mode = Deferre
         /// <param name="defer_mode">How to handle deferred loading.</param>
         public static Datamodel Load(byte[] data, DeferredMode defer_mode = DeferredMode.Automatic)
         {
-            return Load_Internal<Element>(new MemoryStream(data, true),defer_mode);
+            return Load_Internal<Element>(new MemoryStream(data, true), defer_mode);
         }
         /// <summary>
         /// Loads a Datamodel from a byte array.
@@ -287,7 +287,7 @@ public static Datamodel Load(string path, DeferredMode defer_mode = DeferredMode
             Datamodel? dm = null;
             try
             {
-                dm = Load_Internal<Element>(stream,defer_mode);
+                dm = Load_Internal<Element>(stream, defer_mode);
                 return dm;
             }
             finally
@@ -310,22 +310,22 @@ public static Datamodel Load<T>(string path, ReflectionParams? reflectionParams
         private static Datamodel Load_Internal<T>(Stream stream, DeferredMode defer_mode = DeferredMode.Automatic, ReflectionParams? reflectionParams = null)
             where T : Element
         {
-            reflectionParams ??= new ();
+            reflectionParams ??= new();
 
             var templateType = typeof(T);
 
-            if(templateType is null)
+            if (templateType is null)
             {
                 throw new InvalidDataException("Template type can't be null");
             }
 
-            if(templateType == typeof(Element))
+            if (templateType == typeof(Element))
             {
                 reflectionParams.AttemptReflection = false;
             }
 
             // if user doesnt specify these assume assembly and namespace of root node
-            if(reflectionParams.Assembly == string.Empty)
+            if (reflectionParams.Assembly == string.Empty)
             {
                 reflectionParams.Assembly = templateType.Assembly.GetName().Name!;
             }
@@ -389,7 +389,7 @@ private static Datamodel Load_Internal<T>(Stream stream, DeferredMode defer_mode
             {
                 result = StubRequest(id);
 
-                if(result is null)
+                if (result is null)
                 {
                     throw new InvalidDataException("Stub request failed, result was null");
                 }
@@ -484,7 +484,7 @@ public string Format
             get => _Format;
             set
             {
-                if(value is null)
+                if (value is null)
                 {
                     throw new InvalidDataException("Format can not be null");
                 }
@@ -519,7 +519,7 @@ public string Encoding
             get => _Encoding;
             set
             {
-                if(value is null)
+                if (value is null)
                 {
                     throw new InvalidDataException("Encoding can not be null");
                 }
@@ -779,7 +779,7 @@ public ImportJob(ImportRecursionMode import_mode, ImportOverwriteMode overwrite_
                         local_element = null;
                 }
 
-                if(local_element is null)
+                if (local_element is null)
                 {
                     return null;
                 }
@@ -799,7 +799,7 @@ public ImportJob(ImportRecursionMode import_mode, ImportOverwriteMode overwrite_
                             var list = (System.Collections.ICollection)attr.Value;
                             var inner_type = GetArrayInnerType(list.GetType());
 
-                            if(inner_type is null)
+                            if (inner_type is null)
                             {
                                 throw new InvalidOperationException("Failed to get inner_type while importing element");
                             }
@@ -935,7 +935,7 @@ internal DestubException(ElementArray array, int index, Exception innerException
             : base("An exception occured while destubbing an array item.", innerException)
         {
             var arrayOwner = array.Owner;
-            if(arrayOwner is not null)
+            if (arrayOwner is not null)
             {
                 Data.Add("Element", ((Element)arrayOwner).ID);
             }
diff --git a/ElementFactoryGenerator/ElementFactory.cs b/ElementFactoryGenerator/ElementFactory.cs
@@ -179,7 +179,7 @@ private static bool ValidateType(INamedTypeSymbol type, Compilation compilation)
             // only internal classes in execution assembly are fine
             if (type.DeclaredAccessibility == Accessibility.Internal)
             {
-                if(compilation.Assembly != type.ContainingAssembly)
+                if (!SymbolEqualityComparer.Default.Equals(compilation.Assembly, type.ContainingAssembly))
                 {
                     return false;
                 }

Original file line number	Diff line number	Diff line change
`@@ -181,8 +181,8 @@ internal set`
`181`	`181`	`if (elem.Owner == null)`
`182`	`182`	`{`
`183`	`183`	`var importedElement = OwnerDatamodel.ImportElement(elem, Datamodel.ImportRecursionMode.Stubs, Datamodel.ImportOverwriteMode.Stubs);`
`184`		`-`
`185`		`- if(importedElement is not null)`
	`184`	`+`
	`185`	`+ if (importedElement is not null)`
`186`	`186`	`{`
`187`	`187`	`Inner[i] = importedElement;`
`188`	`188`	`}`
`@@ -201,8 +201,8 @@ protected override void Insert_Internal(int index, Element item)`
`201`	`201`	`if (item.Owner == null)`
`202`	`202`	`{`
`203`	`203`	`var importedElement = OwnerDatamodel.ImportElement(item, Datamodel.ImportRecursionMode.Recursive, Datamodel.ImportOverwriteMode.Stubs);`
`204`		`-`
`205`		`- if(importedElement is not null)`
	`204`	`+`
	`205`	`+ if (importedElement is not null)`
`206`	`206`	`{`
`207`	`207`	`item = importedElement;`
`208`	`208`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ private ICollection<Attribute> GetPropertyBasedAttributes(bool useSerializationN`
`29`	`29`	`var result = new List<Attribute>();`
`30`	`30`	`foreach (DictionaryEntry entry in PropertyInfos)`
`31`	`31`	`{`
`32`		`- if(entry.Value is null)`
	`32`	`+ if (entry.Value is null)`
`33`	`33`	`{`
`34`	`34`	`throw new InvalidDataException("Property value can not be null");`
`35`	`35`	`}`
`@@ -135,7 +135,7 @@ public void Add(string key, object? value)`
`135`	`135`	`{`
`136`	`136`	`var attrib = Inner[key];`
`137`	`137`
`138`		`- if(attrib is null)`
	`138`	`+ if (attrib is null)`
`139`	`139`	`{`
`140`	`140`	`return null;`
`141`	`141`	`}`
`@@ -269,7 +269,7 @@ public virtual object? this[string name]`
`269`	`269`	`{`
`270`	`270`	`// were actually fine with this being null, it will just set the value to null`
`271`	`271`	`// but need to check so the type check doesn't fail if it is null`
`272`		`- if(value != null)`
	`272`	`+ if (value != null)`
`273`	`273`	`{`
`274`	`274`	`var valueType = value.GetType();`
`275`	`275`
`@@ -307,7 +307,7 @@ public virtual object? this[string name]`
`307`	`307`
`308`	`308`	`return;`
`309`	`309`	`}`
`310`		`-`
	`310`	`+`
`311`	`311`	`Attribute? old_attr;`
`312`	`312`	`Attribute? new_attr;`
`313`	`313`	`int old_index = -1;`
`@@ -343,7 +343,7 @@ public AttrKVP this[int index]`
`343`	`343`	`{`
`344`	`344`	`var attr = (Attribute?)Inner[index];`
`345`	`345`
`346`		`- if(attr is null)`
	`346`	`+ if (attr is null)`
`347`	`347`	`{`
`348`	`348`	`throw new InvalidOperationException($"attribute at index {index} doesn't exist");`
`349`	`349`	`}`
`@@ -367,7 +367,7 @@ public void RemoveAt(int index)`
`367`	`367`	`{`
`368`	`368`	`attr = (Attribute?)Inner[index];`
`369`	`369`
`370`		`- if(attr is not null)`
	`370`	`+ if (attr is not null)`
`371`	`371`	`{`
`372`	`372`	`attr.Owner = null;`
`373`	`373`	`Inner.RemoveAt(index);`
`@@ -571,7 +571,7 @@ public static ValueComparer Default`
`571`	`571`
`572`	`572`	`public new bool Equals(object? x, object? y)`
`573`	`573`	`{`
`574`		`- if(x is null \|\| y is null)`
	`574`	`+ if (x is null \|\| y is null)`
`575`	`575`	`{`
`576`	`576`	`return false;`
`577`	`577`	`}`
Original file line number	Diff line number	Diff line change
`@@ -219,7 +219,7 @@ public void Trim()`
`219`	`219`	`{`
`220`	`220`	`foreach (var elem in this.Except(used).ToArray())`
`221`	`221`	`{`
`222`		`- if(elem != null)`
	`222`	`+ if (elem != null)`
`223`	`223`	`{`
`224`	`224`	`store.Remove(elem.ID);`
`225`	`225`	`elem.Owner = null;`
`@@ -241,7 +241,7 @@ public void Trim()`
`241`	`241`
`242`	`242`	`protected void WalkElemTree(Element? elem, HashSet<Element?> found)`
`243`	`243`	`{`
`244`		`- if(elem is null)`
	`244`	`+ if (elem is null)`
`245`	`245`	`{`
`246`	`246`	`return;`
`247`	`247`	`}`
Original file line number	Diff line number	Diff line change
`@@ -167,7 +167,7 @@ private static ICodec GetCodec(string encoding, int encoding_version)`
`167`	`167`
`168`	`168`	`var codecConstructor = codec_type.GetConstructor(Type.EmptyTypes);`
`169`	`169`
`170`		`- if(codecConstructor is null)`
	`170`	`+ if (codecConstructor is null)`
`171`	`171`	`{`
`172`	`172`	`throw new InvalidOperationException("Failed to get codec constructor.");`
`173`	`173`	`}`
`@@ -252,7 +252,7 @@ public static Datamodel Load(Stream stream, DeferredMode defer_mode = DeferredMo`
`252`	`252`	`public static Datamodel Load<T>(Stream stream, DeferredMode defer_mode = DeferredMode.Automatic, ReflectionParams? reflectionParams = null)`
`253`	`253`	`where T : Element`
`254`	`254`	`{`
`255`		`- return Load_Internal<T>(stream,defer_mode, reflectionParams);`
	`255`	`+ return Load_Internal<T>(stream, defer_mode, reflectionParams);`
`256`	`256`	`}`
`257`	`257`
`258`	`258`	`/// <summary>`
`@@ -262,7 +262,7 @@ public static Datamodel Load<T>(Stream stream, DeferredMode defer_mode = Deferre`
`262`	`262`	`/// <param name="defer_mode">How to handle deferred loading.</param>`
`263`	`263`	`public static Datamodel Load(byte[] data, DeferredMode defer_mode = DeferredMode.Automatic)`
`264`	`264`	`{`
`265`		`- return Load_Internal<Element>(new MemoryStream(data, true),defer_mode);`
	`265`	`+ return Load_Internal<Element>(new MemoryStream(data, true), defer_mode);`
`266`	`266`	`}`
`267`	`267`	`/// <summary>`
`268`	`268`	`/// Loads a Datamodel from a byte array.`
`@@ -287,7 +287,7 @@ public static Datamodel Load(string path, DeferredMode defer_mode = DeferredMode`
`287`	`287`	`Datamodel? dm = null;`
`288`	`288`	`try`
`289`	`289`	`{`
`290`		`- dm = Load_Internal<Element>(stream,defer_mode);`
	`290`	`+ dm = Load_Internal<Element>(stream, defer_mode);`
`291`	`291`	`return dm;`
`292`	`292`	`}`
`293`	`293`	`finally`
`@@ -310,22 +310,22 @@ public static Datamodel Load<T>(string path, ReflectionParams? reflectionParams`
`310`	`310`	`private static Datamodel Load_Internal<T>(Stream stream, DeferredMode defer_mode = DeferredMode.Automatic, ReflectionParams? reflectionParams = null)`
`311`	`311`	`where T : Element`
`312`	`312`	`{`
`313`		`- reflectionParams ??= new ();`
	`313`	`+ reflectionParams ??= new();`
`314`	`314`
`315`	`315`	`var templateType = typeof(T);`
`316`	`316`
`317`		`- if(templateType is null)`
	`317`	`+ if (templateType is null)`
`318`	`318`	`{`
`319`	`319`	`throw new InvalidDataException("Template type can't be null");`
`320`	`320`	`}`
`321`	`321`
`322`		`- if(templateType == typeof(Element))`
	`322`	`+ if (templateType == typeof(Element))`
`323`	`323`	`{`
`324`	`324`	`reflectionParams.AttemptReflection = false;`
`325`	`325`	`}`
`326`	`326`
`327`	`327`	`// if user doesnt specify these assume assembly and namespace of root node`
`328`		`- if(reflectionParams.Assembly == string.Empty)`
	`328`	`+ if (reflectionParams.Assembly == string.Empty)`
`329`	`329`	`{`
`330`	`330`	`reflectionParams.Assembly = templateType.Assembly.GetName().Name!;`
`331`	`331`	`}`
`@@ -389,7 +389,7 @@ private static Datamodel Load_Internal<T>(Stream stream, DeferredMode defer_mode`
`389`	`389`	`{`
`390`	`390`	`result = StubRequest(id);`
`391`	`391`
`392`		`- if(result is null)`
	`392`	`+ if (result is null)`
`393`	`393`	`{`
`394`	`394`	`throw new InvalidDataException("Stub request failed, result was null");`
`395`	`395`	`}`
`@@ -484,7 +484,7 @@ public string Format`
`484`	`484`	`get => _Format;`
`485`	`485`	`set`
`486`	`486`	`{`
`487`		`- if(value is null)`
	`487`	`+ if (value is null)`
`488`	`488`	`{`
`489`	`489`	`throw new InvalidDataException("Format can not be null");`
`490`	`490`	`}`
`@@ -519,7 +519,7 @@ public string Encoding`
`519`	`519`	`get => _Encoding;`
`520`	`520`	`set`
`521`	`521`	`{`
`522`		`- if(value is null)`
	`522`	`+ if (value is null)`
`523`	`523`	`{`
`524`	`524`	`throw new InvalidDataException("Encoding can not be null");`
`525`	`525`	`}`
`@@ -779,7 +779,7 @@ public ImportJob(ImportRecursionMode import_mode, ImportOverwriteMode overwrite_`
`779`	`779`	`local_element = null;`
`780`	`780`	`}`
`781`	`781`
`782`		`- if(local_element is null)`
	`782`	`+ if (local_element is null)`
`783`	`783`	`{`
`784`	`784`	`return null;`
`785`	`785`	`}`
`@@ -799,7 +799,7 @@ public ImportJob(ImportRecursionMode import_mode, ImportOverwriteMode overwrite_`
`799`	`799`	`var list = (System.Collections.ICollection)attr.Value;`
`800`	`800`	`var inner_type = GetArrayInnerType(list.GetType());`
`801`	`801`
`802`		`- if(inner_type is null)`
	`802`	`+ if (inner_type is null)`
`803`	`803`	`{`
`804`	`804`	`throw new InvalidOperationException("Failed to get inner_type while importing element");`
`805`	`805`	`}`
`@@ -935,7 +935,7 @@ internal DestubException(ElementArray array, int index, Exception innerException`
`935`	`935`	`: base("An exception occured while destubbing an array item.", innerException)`
`936`	`936`	`{`
`937`	`937`	`var arrayOwner = array.Owner;`
`938`		`- if(arrayOwner is not null)`
	`938`	`+ if (arrayOwner is not null)`
`939`	`939`	`{`
`940`	`940`	`Data.Add("Element", ((Element)arrayOwner).ID);`
`941`	`941`	`}`
Original file line number	Diff line number	Diff line change
`@@ -179,7 +179,7 @@ private static bool ValidateType(INamedTypeSymbol type, Compilation compilation)`
`179`	`179`	`// only internal classes in execution assembly are fine`
`180`	`180`	`if (type.DeclaredAccessibility == Accessibility.Internal)`
`181`	`181`	`{`
`182`		`- if(compilation.Assembly != type.ContainingAssembly)`
	`182`	`+ if (!SymbolEqualityComparer.Default.Equals(compilation.Assembly, type.ContainingAssembly))`
`183`	`183`	`{`
`184`	`184`	`return false;`
`185`	`185`	`}`