Smaller files refactoring

Code/Light.GuardClauses/CallerArgumentExpressionAttribute.cs

@@ -2,14 +2,12 @@
 // ReSharper disable once CheckNamespace -- CallerArgumentExpression must be in exactly this namespace
 namespace System.Runtime.CompilerServices;
 
-[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
+[AttributeUsage(AttributeTargets.Parameter)]
 internal sealed class CallerArgumentExpressionAttribute : Attribute
 {
-    public CallerArgumentExpressionAttribute(string parameterName)
-    {
+    public CallerArgumentExpressionAttribute(string parameterName) =>
         ParameterName = parameterName;
-    }
 
     public string ParameterName { get; }
 }
-#endif
+#endif

Code/Light.GuardClauses/Check.Contains.cs

@@ -0,0 +1,28 @@
+using System;
+using System.Runtime.CompilerServices;
+using JetBrains.Annotations;
+using NotNullAttribute = System.Diagnostics.CodeAnalysis.NotNullAttribute;
+
+namespace Light.GuardClauses;
+
+public static partial class Check
+{
+    /// <summary>
+    /// Checks if the string contains the specified value using the given comparison type.
+    /// </summary>
+    /// <param name="string">The string to be checked.</param>
+    /// <param name="value">The other string.</param>
+    /// <param name="comparisonType">One of the enumeration values that specifies the rules for the search.</param>
+    /// <returns>True if <paramref name="string" /> contains <paramref name="value" />, else false.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="string" /> or <paramref name="value" /> is null.</exception>
+    /// <exception cref="ArgumentException">Thrown when <paramref name="comparisonType" /> is not a valid <see cref="StringComparison" /> value.</exception>
+    [MethodImpl(MethodImplOptions.AggressiveInlining)]
+    [ContractAnnotation("string:null => halt; value:null => halt")]
+    public static bool Contains(
+        // ReSharper disable once RedundantNullableFlowAttribute -- Caller might have NRTs turned off
+        [NotNull] [ValidatedNotNull] this string @string,
+        string value,
+        StringComparison comparisonType
+    ) =>
+        @string.MustNotBeNull(nameof(@string)).IndexOf(value.MustNotBeNull(nameof(value)), comparisonType) >= 0;
+}

Code/Light.GuardClauses/Check.DerivesFrom.cs

@@ -0,0 +1,76 @@
+#if NET8_0
+using System.Diagnostics.CodeAnalysis;
+#endif
+using System;
+using System.Collections.Generic;
+using JetBrains.Annotations;
+using NotNullAttribute = System.Diagnostics.CodeAnalysis.NotNullAttribute;
+
+// ReSharper disable RedundantNullableFlowAttribute -- NotNull has an effect, see Issue72NotNullAttributeTests
+
+
+namespace Light.GuardClauses;
+
+public static partial class Check
+{
+    /// <summary>
+    /// Checks if the specified type derives from the other type. Internally, this method uses <see cref="IsEquivalentTypeTo" />
+    /// by default so that constructed generic types and their corresponding generic type definitions are regarded as equal.
+    /// </summary>
+    /// <param name="type">The type info to be checked.</param>
+    /// <param name="baseClass">The base class that <paramref name="type" /> should derive from.</param>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="type" /> or <paramref name="baseClass" /> is null.</exception>
+    [ContractAnnotation("type:null => halt; baseClass:null => halt")]
+    public static bool DerivesFrom(
+        [NotNull] [ValidatedNotNull] this Type type,
+        [NotNull] [ValidatedNotNull] Type baseClass
+    )
+    {
+        baseClass.MustNotBeNull(nameof(baseClass));
+
+        var currentBaseType = type.MustNotBeNull(nameof(type)).BaseType;
+        while (currentBaseType != null)
+        {
+            if (currentBaseType.IsEquivalentTypeTo(baseClass))
+            {
+                return true;
+            }
+
+            currentBaseType = currentBaseType.BaseType;
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Checks if the specified type derives from the other type. This overload uses the specified <paramref name="typeComparer" />
+    /// to compare the types.
+    /// </summary>
+    /// <param name="type">The type info to be checked.</param>
+    /// <param name="baseClass">The base class that <paramref name="type" /> should derive from.</param>
+    /// <param name="typeComparer">The equality comparer used to compare the types.</param>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="type" />, or <paramref name="baseClass" />, or <paramref name="typeComparer" /> is null.</exception>
+    [ContractAnnotation("type:null => halt; baseClass:null => halt; typeComparer:null => halt")]
+    public static bool DerivesFrom(
+        [NotNull] [ValidatedNotNull] this Type type,
+        [NotNull] [ValidatedNotNull] Type baseClass,
+        [NotNull] [ValidatedNotNull] IEqualityComparer<Type> typeComparer
+    )
+    {
+        baseClass.MustNotBeNull(nameof(baseClass));
+        typeComparer.MustNotBeNull(nameof(typeComparer));
+
+        var currentBaseType = type.MustNotBeNull(nameof(type)).BaseType;
+        while (currentBaseType != null)
+        {
+            if (typeComparer.Equals(currentBaseType, baseClass))
+            {
+                return true;
+            }
+
+            currentBaseType = currentBaseType.BaseType;
+        }
+
+        return false;
+    }
+}