KnownReference: Add support for testing for referenced libraries

analyzers/src/SonarAnalyzer.Common/Extensions/CompilationExtensions.cs

@@ -24,4 +24,17 @@ internal static class CompilationExtensions
 {
     public static INamedTypeSymbol GetTypeByMetadataName(this Compilation compilation, KnownType knownType) =>
         compilation.GetTypeByMetadataName(knownType.FullName);
+
+    public static IMethodSymbol GetTypeMethod(this Compilation compilation, SpecialType type, string methodName) =>
+        (IMethodSymbol)compilation.GetSpecialType(type)
+            .GetMembers(methodName)
+            .SingleOrDefault();
+
+    public static bool IsNetFrameworkTarget(this Compilation compilation) =>
+        // There's no direct way of checking compilation target framework yet (09/2020).
+        // See https://github.com/dotnet/roslyn/issues/3798
+        compilation.ObjectType.ContainingAssembly.Name == "mscorlib";
+
+    public static bool References(this Compilation compilation, KnownReference reference)
+        => reference.IsReferencedBy(compilation);
 }

analyzers/src/SonarAnalyzer.Common/Helpers/CompilationExtensions.cs → analyzers/src/SonarAnalyzer.Common/Extensions/KnownReferenceExtensions.cs

@@ -18,18 +18,10 @@
  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
-namespace SonarAnalyzer.Helpers
-{
-    public static class CompilationExtensions
-    {
-        public static IMethodSymbol GetTypeMethod(this Compilation compilation, SpecialType type, string methodName) =>
-            (IMethodSymbol)compilation.GetSpecialType(type)
-                .GetMembers(methodName)
-                .SingleOrDefault();
+namespace SonarAnalyzer.Extensions;
 
-        public static bool IsNetFrameworkTarget(this Compilation compilation) =>
-            // There's no direct way of checking compilation target framework yet (09/2020).
-            // See https://github.com/dotnet/roslyn/issues/3798
-            compilation.ObjectType.ContainingAssembly.Name == "mscorlib";
-    }
+internal static class KnownReferenceExtensions
+{
+    internal static Func<AssemblyIdentity, bool> And(this Func<AssemblyIdentity, bool> @this, Func<AssemblyIdentity, bool> predicate)
+        => identity => @this(identity) && predicate(identity);
 }

analyzers/src/SonarAnalyzer.Common/Helpers/KnownReference.Predicates.cs

@@ -0,0 +1,77 @@
+/*
+ * SonarAnalyzer for .NET
+ * Copyright (C) 2015-2023 SonarSource SA
+ * mailto: contact AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+using System.ComponentModel;
+
+namespace SonarAnalyzer.Helpers;
+
+public sealed partial class KnownReference
+{
+    private const StringComparison AssemblyNameComparission = StringComparison.OrdinalIgnoreCase;
+
+    [EditorBrowsable(EditorBrowsableState.Never)]
+    internal static class Predicates
+    {
+        internal static Func<AssemblyIdentity, bool> NameIs(string name) =>
+            x => x.Name.Equals(name, AssemblyNameComparission);
+
+        internal static Func<AssemblyIdentity, bool> StartsWith(string name) =>
+            x => x.Name.StartsWith(name, AssemblyNameComparission);
+
+        internal static Func<AssemblyIdentity, bool> EndsWith(string name) =>
+            x => x.Name.EndsWith(name, AssemblyNameComparission);
+
+        internal static Func<AssemblyIdentity, bool> Contains(string name) =>
+            x => x.Name.IndexOf(name, 0, AssemblyNameComparission) >= 0;
+
+        internal static Func<AssemblyIdentity, bool> VersionLowerThen(string version) =>
+            VersionLowerThen(Version.Parse(version));
+
+        internal static Func<AssemblyIdentity, bool> VersionLowerThen(Version version) =>
+            x => x.Version < version;
+
+        internal static Func<AssemblyIdentity, bool> VersionGreaterOrEqual(string version) =>
+            VersionGreaterOrEqual(Version.Parse(version));
+
+        internal static Func<AssemblyIdentity, bool> VersionGreaterOrEqual(Version version) =>
+            x => x.Version >= version;
+
+        internal static Func<AssemblyIdentity, bool> VersionBetween(string from, string to) =>
+            VersionBetween(Version.Parse(from), Version.Parse(to));
+
+        internal static Func<AssemblyIdentity, bool> VersionBetween(Version from, Version to) =>
+            x => x.Version >= from && x.Version <= to;
+
+        internal static Func<AssemblyIdentity, bool> OptionalPublicKeyTokenIs(string key) =>
+            x => !x.HasPublicKey || PublicKeyEqualHex(x, key);
+
+        internal static Func<AssemblyIdentity, bool> PublicKeyTokenIs(string key) =>
+            x => x.HasPublicKey && PublicKeyEqualHex(x, key);
+
+        private static bool PublicKeyEqualHex(AssemblyIdentity identity, string hexString)
+        {
+            var normalizedHexString = hexString.Replace("-", string.Empty);
+            return ArraysEqual(identity.PublicKeyToken.ToArray(), normalizedHexString) || ArraysEqual(identity.PublicKey.ToArray(), normalizedHexString);
+
+            static bool ArraysEqual(byte[] key, string hexString) =>
+                BitConverter.ToString(key).Replace("-", string.Empty).Equals(hexString, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+}

analyzers/src/SonarAnalyzer.Common/Helpers/KnownReference.cs

@@ -0,0 +1,46 @@
+/*
+ * SonarAnalyzer for .NET
+ * Copyright (C) 2015-2023 SonarSource SA
+ * mailto: contact AT sonarsource DOT com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+using static SonarAnalyzer.Helpers.KnownReference.Predicates;
+
+namespace SonarAnalyzer.Helpers
+{
+    public sealed partial class KnownReference
+    {
+        private readonly Func<IEnumerable<AssemblyIdentity>, bool> predicate;
+
+        public static KnownReference XUnit_Assert { get; } = new(
+            NameIs("xunit.assert"),
+            NameIs("xunit").And(VersionLowerThen("2.0")));
+
+        internal KnownReference(Func<AssemblyIdentity, bool> predicate, params Func<AssemblyIdentity, bool>[] or)
+            : this(predicate is null || or.Any(x => x is null)
+                  ? throw new ArgumentNullException(nameof(predicate), "All predicates must be non-null.")
+                  : identities => identities.Any(identitiy => predicate(identitiy) || or.Any(orPredicate => orPredicate(identitiy))))
+        {
+        }
+
+        internal KnownReference(Func<IEnumerable<AssemblyIdentity>, bool> predicate) =>
+            this.predicate = predicate ?? throw new ArgumentNullException(nameof(predicate));
+
+        public bool IsReferencedBy(Compilation compilation) =>
+            predicate(compilation.ReferencedAssemblyNames);
+    }
+}