use .NET 8.0 assembies for coverlet.core and remove Newtonsoft.Json

Bertk · Bertk · commit 68786338af7c · 2025-01-27T10:57:22.000+01:00
diff --git a/Directory.Packages.props b/Directory.Packages.props
@@ -30,7 +30,6 @@
          vstest 17.8 version
          NuGetFrameworksVersion is defined here https://github.com/microsoft/vstest/blob/9a0c41811637edf4afe0e265e08fdd1cb18109ed/eng/Versions.props#L94C1-L94C1
     -->
-    <PackageVersion Include="Newtonsoft.Json" Version="13.0.3" />
     <PackageVersion Include="NuGet.Frameworks" Version="6.12.1" />
     <PackageVersion Include="NuGet.Packaging" Version="6.12.1" />
     <PackageVersion Include="NuGet.Versioning" Version="6.12.1" />
diff --git a/README.md b/README.md
@@ -44,8 +44,8 @@ Coverlet supports only SDK-style projects https://docs.microsoft.com/en-us/visua
 ```bash
 dotnet add package coverlet.collector
 ```
-
-N.B. You **MUST** add package only to test projects and if you create xunit test projects (`dotnet new xunit`) you'll find the reference already present in `csproj` file because Coverlet is the default coverage tool for every .NET Core and >= .NET 6 applications, you've only to update to last version if needed. Do not add `coverlet.collector` and `coverlet.msbuild` package in a test project.
+> [!NOTE]
+> You **MUST** add package only to test projects and if you create xunit test projects (`dotnet new xunit`) you will find the reference already present in `csproj` file because Coverlet is the default coverage tool for every .NET Core and >= *.NET 8* applications, you've only to update to last version if needed. Add `coverlet.collector` *OR* `coverlet.msbuild` package in a test project.
 
 ### Usage (coverlet.collector)
 
@@ -61,11 +61,11 @@ See [documentation](Documentation/VSTestIntegration.md) for advanced usage.
 
 #### Requirements (coverlet.collector)
 
-* _You need to be running .NET 6.0 SDK v6.0.316 or newer_
-* _You need to reference version 17.5.0 and above of Microsoft.NET.Test.Sdk_
+* _You need to be running .NET 8.0 SDK v8.0.112 or newer_
+* _You need to reference version 17.12.0 and above of Microsoft.NET.Test.Sdk_
 
 ```xml
-<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.5.0" />
+<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
 ```
 
 ### MSBuild Integration (suffers of possible [known issue](https://github.com/coverlet-coverage/coverlet/blob/master/Documentation/KnownIssues.md#1-vstest-stops-process-execution-earlydotnet-test))
@@ -120,7 +120,7 @@ See [documentation](Documentation/GlobalTool.md) for advanced usage.
 
 .NET global tools rely on a .NET Core runtime installed on your machine https://docs.microsoft.com/en-us/dotnet/core/tools/global-tools#what-could-go-wrong
 
-.NET Coverlet global tool requires _.NET Core 2.2 and above_
+.NET Coverlet global tool requires _.NET 8.0 or above_
 
 ## How It Works
 
diff --git a/src/coverlet.core/Coverage.cs b/src/coverlet.core/Coverage.cs
@@ -6,11 +6,11 @@
 using System.IO;
 using System.Linq;
 using System.Runtime.Serialization;
+using System.Text.Json;
+using System.Text.Json.Nodes;
 using Coverlet.Core.Abstractions;
 using Coverlet.Core.Helpers;
 using Coverlet.Core.Instrumentation;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
 
 namespace Coverlet.Core
 {
@@ -60,6 +60,14 @@ internal class Coverage
 
     public string Identifier { get; }
 
+    readonly JsonSerializerOptions _options = new()
+    {
+      PropertyNameCaseInsensitive = true,
+      DictionaryKeyPolicy = JsonNamingPolicy.CamelCase,
+      IncludeFields = true,
+      WriteIndented = true
+    };
+
     public Coverage(string moduleOrDirectory,
         CoverageParameters parameters,
         ILogger logger,
@@ -313,7 +321,7 @@ public CoverageResult GetCoverageResult()
         {
           _logger.LogInformation($"MergeWith: '{_parameters.MergeWith}'.");
           string json = _fileSystem.ReadAllText(_parameters.MergeWith);
-          coverageResult.Merge(JsonConvert.DeserializeObject<Modules>(json));
+          coverageResult.Merge(JsonSerializer.Deserialize<Modules>(json, _options));
         }
         else
         {
@@ -366,8 +374,8 @@ private void CalculateCoverage()
         var documents = result.Documents.Values.ToList();
         if (_parameters.UseSourceLink && result.SourceLink != null)
         {
-          JToken jObject = JObject.Parse(result.SourceLink)["documents"];
-          Dictionary<string, string> sourceLinkDocuments = JsonConvert.DeserializeObject<Dictionary<string, string>>(jObject.ToString());
+          JsonNode jObject = JsonNode.Parse(result.SourceLink)["documents"];
+          Dictionary<string, string> sourceLinkDocuments = JsonSerializer.Deserialize<Dictionary<string, string>>(jObject.ToString());
           foreach (Document document in documents)
           {
             document.Path = GetSourceLinkUrl(sourceLinkDocuments, document.Path);
diff --git a/src/coverlet.core/CoverageResult.cs b/src/coverlet.core/CoverageResult.cs
@@ -3,6 +3,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using System.Text.Json.Serialization;
 using Coverlet.Core.Enums;
 using Coverlet.Core.Instrumentation;
 
@@ -22,6 +23,7 @@ internal class Branches : List<BranchInfo> { }
 
   internal class Method
   {
+    [JsonConstructor]
     internal Method()
     {
       Lines = new Lines();
diff --git a/src/coverlet.core/Exceptions.cs b/src/coverlet.core/Exceptions.cs
@@ -5,25 +5,17 @@
 
 namespace Coverlet.Core.Exceptions
 {
-  [Serializable]
   public class CoverletException : Exception
   {
     public CoverletException() { }
     public CoverletException(string message) : base(message) { }
     public CoverletException(string message, System.Exception inner) : base(message, inner) { }
-    protected CoverletException(
-      System.Runtime.Serialization.SerializationInfo info,
-      System.Runtime.Serialization.StreamingContext context) : base(info, context) { }
   }
 
-  [Serializable]
   internal class CecilAssemblyResolutionException : CoverletException
   {
     public CecilAssemblyResolutionException() { }
     public CecilAssemblyResolutionException(string message) : base(message) { }
     public CecilAssemblyResolutionException(string message, System.Exception inner) : base(message, inner) { }
-    protected CecilAssemblyResolutionException(
-      System.Runtime.Serialization.SerializationInfo info,
-      System.Runtime.Serialization.StreamingContext context) : base(info, context) { }
   }
 }
diff --git a/src/coverlet.core/Helpers/InstrumentationHelper.cs b/src/coverlet.core/Helpers/InstrumentationHelper.cs
@@ -415,17 +415,21 @@ private static string GetIncludeModuleKeysForValidFilters(char escapeSymbol, str
     }
 
     private static string CreateRegexExcludePattern(IEnumerable<string> filters, char escapeSymbol)
-      //only look for module filters here, types will be filtered out when instrumenting 
+      //only look for module filters here, types will be filtered out when instrumenting
+#pragma warning disable IDE0057 // Use range operator
       => CreateRegexPattern(filters, escapeSymbol, filter => filter.Substring(filter.IndexOf(']') + 1) == "*");
+#pragma warning restore IDE0057 // Use range operator
 
     private static string CreateRegexIncludePattern(IEnumerable<string> filters, char escapeSymbol) =>
       CreateRegexPattern(filters, escapeSymbol);
 
     private static string CreateRegexPattern(IEnumerable<string> filters, char escapeSymbol, Func<string, bool> filterPredicate = null)
     {
       IEnumerable<string> filteredFilters = filterPredicate != null ? filters.Where(filterPredicate) : filters;
+#pragma warning disable IDE0057 // Use range operator
       IEnumerable<string> regexPatterns = filteredFilters.Select(x =>
         $"{escapeSymbol}{WildcardToRegex(x.Substring(1, x.IndexOf(']') - 1)).Trim('^', '$')}{escapeSymbol}");
+#pragma warning restore IDE0057 // Use range operator
       return string.Join("|", regexPatterns);
     }
 
diff --git a/src/coverlet.core/Instrumentation/CecilAssemblyResolver.cs b/src/coverlet.core/Instrumentation/CecilAssemblyResolver.cs
@@ -5,12 +5,12 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Text.Json;
 using Coverlet.Core.Abstractions;
 using Coverlet.Core.Exceptions;
 using Microsoft.Extensions.DependencyModel;
 using Microsoft.Extensions.DependencyModel.Resolution;
 using Mono.Cecil;
-using Newtonsoft.Json.Linq;
 using NuGet.Versioning;
 
 namespace Coverlet.Core.Instrumentation
@@ -298,29 +298,29 @@ public RuntimeConfigurationReader(string runtimeConfigFile)
     {
       string jsonString = File.ReadAllText(_runtimeConfigFile);
 
-      var jsonLoadSettings = new JsonLoadSettings()
+      var documentOptions = new JsonDocumentOptions
       {
-        CommentHandling = CommentHandling.Ignore
+        CommentHandling = JsonCommentHandling.Skip
       };
 
-      var configuration = JObject.Parse(jsonString, jsonLoadSettings);
+      using var configuration = JsonDocument.Parse(jsonString, documentOptions);
 
-      JToken rootElement = configuration.Root;
-      JToken runtimeOptionsElement = rootElement["runtimeOptions"];
+      JsonElement rootElement = configuration.RootElement;
+      JsonElement runtimeOptionsElement = rootElement.GetProperty("runtimeOptions");
 
-      if (runtimeOptionsElement?["framework"] != null)
+      if (runtimeOptionsElement.TryGetProperty("framework", out JsonElement frameworkElement))
       {
-        return new[] { (runtimeOptionsElement["framework"]["name"]?.Value<string>(), runtimeOptionsElement["framework"]["version"]?.Value<string>()) };
+        return new[] { (frameworkElement.GetProperty("name").GetString(), frameworkElement.GetProperty("version").GetString()) };
       }
 
-      if (runtimeOptionsElement?["frameworks"] != null)
+      if (runtimeOptionsElement.TryGetProperty("frameworks", out JsonElement frameworksElement))
       {
-        return runtimeOptionsElement["frameworks"].Select(x => (x["name"]?.Value<string>(), x["version"]?.Value<string>())).ToList();
+        return frameworksElement.EnumerateArray().Select(x => (x.GetProperty("name").GetString(), x.GetProperty("version").GetString())).ToList();
       }
 
-      if (runtimeOptionsElement?["includedFrameworks"] != null)
+      if (runtimeOptionsElement.TryGetProperty("includedframeworks", out JsonElement runtimeoptionselement))
       {
-        return runtimeOptionsElement["includedFrameworks"].Select(x => (x["name"]?.Value<string>(), x["version"]?.Value<string>())).ToList();
+        return runtimeoptionselement.EnumerateArray().Select(x => (x.GetProperty("name").GetString(), x.GetProperty("version").GetString())).ToList();
       }
 
       throw new InvalidOperationException($"Unable to read runtime configuration from {_runtimeConfigFile}.");
diff --git a/src/coverlet.core/Reporters/JsonReporter.cs b/src/coverlet.core/Reporters/JsonReporter.cs
@@ -1,8 +1,9 @@
 ﻿// Copyright (c) Toni Solarin-Sodara
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
+using System.Text.Encodings.Web;
+using System.Text.Json;
 using Coverlet.Core.Abstractions;
-using Newtonsoft.Json;
 
 namespace Coverlet.Core.Reporters
 {
@@ -16,7 +17,13 @@ internal class JsonReporter : IReporter
 
     public string Report(CoverageResult result, ISourceRootTranslator _)
     {
-      return JsonConvert.SerializeObject(result.Modules, Formatting.Indented);
+      var options = new JsonSerializerOptions
+      {
+        Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
+        IncludeFields = true,
+        WriteIndented = true,
+      };
+      return JsonSerializer.Serialize(result.Modules, options);
     }
   }
 }
diff --git a/src/coverlet.core/coverlet.core.csproj b/src/coverlet.core/coverlet.core.csproj
@@ -2,27 +2,23 @@
 
   <PropertyGroup>
     <OutputType>Library</OutputType>
-    <TargetFrameworks>netstandard2.0</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0;net8.0</TargetFrameworks>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" VersionOverride="6.0.0" />
-    <PackageReference Include="Microsoft.Extensions.DependencyModel" VersionOverride="6.0.2" />
-    <PackageReference Include="Microsoft.Extensions.FileSystemGlobbing" VersionOverride="6.0.0" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" VersionOverride="6.0.2" />
+    <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" />
+    <PackageReference Include="Microsoft.Extensions.DependencyModel" />
+    <PackageReference Include="Microsoft.Extensions.FileSystemGlobbing" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" />
     <PackageReference Include="Mono.Cecil" />
     <PackageReference Include="NuGet.Versioning" />
-    <PackageReference Include="Newtonsoft.Json" />
-    <PackageReference Include="System.Buffers" />
-    <PackageReference Include="System.Memory" />
-    <PackageReference Include="System.Text.Json" VersionOverride="6.0.11" />
-    <PackageReference Include="System.Threading.Tasks.Extensions" />
+    <PackageReference Include="System.Text.Json" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' != 'netstandard2.0'">
-    <PackageReference Include="System.Reflection.Metadata" VersionOverride="6.0.2" />
-    <PackageReference Include="System.Collections.Immutable" VersionOverride="6.0.1" />
+    <PackageReference Include="System.Reflection.Metadata" />
+    <PackageReference Include="System.Collections.Immutable" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
diff --git a/src/coverlet.msbuild.tasks/coverlet.msbuild.targets b/src/coverlet.msbuild.tasks/coverlet.msbuild.targets
@@ -6,7 +6,7 @@
   <PropertyGroup>
     <_CoverletSdkNETCoreSdkVersion>$(NETCoreSdkVersion)</_CoverletSdkNETCoreSdkVersion>
     <_CoverletSdkNETCoreSdkVersion Condition="$(_CoverletSdkNETCoreSdkVersion.Contains('-'))">$(_CoverletSdkNETCoreSdkVersion.Split('-')[0])</_CoverletSdkNETCoreSdkVersion>
-    <_CoverletSdkMinVersionWithDependencyTarget>6.0.100</_CoverletSdkMinVersionWithDependencyTarget>
+    <_CoverletSdkMinVersionWithDependencyTarget>8.0.100</_CoverletSdkMinVersionWithDependencyTarget>
     <_CoverletSourceRootTargetName>CoverletGetPathMap</_CoverletSourceRootTargetName>
     <_CoverletSourceRootTargetName Condition="'$([System.Version]::Parse($(_CoverletSdkNETCoreSdkVersion)).CompareTo($([System.Version]::Parse($(_CoverletSdkMinVersionWithDependencyTarget)))))' &gt;= '0' ">InitializeSourceRootMappedPaths</_CoverletSourceRootTargetName>
   </PropertyGroup>
diff --git a/test/coverlet.core.coverage.tests/coverlet.core.coverage.tests.csproj b/test/coverlet.core.coverage.tests/coverlet.core.coverage.tests.csproj
@@ -23,8 +23,6 @@
     <PackageReference Include="xunit" />
     <PackageReference Include="xunit.runner.visualstudio" />
     <PackageReference Include="System.Linq.Async" />
-    <PackageReference Include="System.Reflection.Metadata" />
-    <PackageReference Include="System.Threading.Tasks.Extensions" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/test/coverlet.core.tests/Coverage/CoverageTests.cs b/test/coverlet.core.tests/Coverage/CoverageTests.cs
diff --git a/test/coverlet.core.tests/coverlet.core.tests.csproj b/test/coverlet.core.tests/coverlet.core.tests.csproj
diff --git a/test/coverlet.integration.tests/coverlet.integration.tests.csproj b/test/coverlet.integration.tests/coverlet.integration.tests.csproj

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`
`4`	`4`	`using System.Collections.Generic;`
`5`	`5`	`using System.Linq;`
	`6`	`+using System.Text.Json.Serialization;`
`6`	`7`	`using Coverlet.Core.Enums;`
`7`	`8`	`using Coverlet.Core.Instrumentation;`
`8`	`9`
`@@ -22,6 +23,7 @@ internal class Branches : List<BranchInfo> { }`
`22`	`23`
`23`	`24`	`internal class Method`
`24`	`25`	`{`
	`26`	`+ [JsonConstructor]`
`25`	`27`	`internal Method()`
`26`	`28`	`{`
`27`	`29`	`Lines = new Lines();`
Original file line number	Diff line number	Diff line change
`@@ -5,25 +5,17 @@`
`5`	`5`
`6`	`6`	`namespace Coverlet.Core.Exceptions`
`7`	`7`	`{`
`8`		`- [Serializable]`
`9`	`8`	`public class CoverletException : Exception`
`10`	`9`	`{`
`11`	`10`	`public CoverletException() { }`
`12`	`11`	`public CoverletException(string message) : base(message) { }`
`13`	`12`	`public CoverletException(string message, System.Exception inner) : base(message, inner) { }`
`14`		`- protected CoverletException(`
`15`		`- System.Runtime.Serialization.SerializationInfo info,`
`16`		`- System.Runtime.Serialization.StreamingContext context) : base(info, context) { }`
`17`	`13`	`}`
`18`	`14`
`19`		`- [Serializable]`
`20`	`15`	`internal class CecilAssemblyResolutionException : CoverletException`
`21`	`16`	`{`
`22`	`17`	`public CecilAssemblyResolutionException() { }`
`23`	`18`	`public CecilAssemblyResolutionException(string message) : base(message) { }`
`24`	`19`	`public CecilAssemblyResolutionException(string message, System.Exception inner) : base(message, inner) { }`
`25`		`- protected CecilAssemblyResolutionException(`
`26`		`- System.Runtime.Serialization.SerializationInfo info,`
`27`		`- System.Runtime.Serialization.StreamingContext context) : base(info, context) { }`
`28`	`20`	`}`
`29`	`21`	`}`
Original file line number	Diff line number	Diff line change
`@@ -415,17 +415,21 @@ private static string GetIncludeModuleKeysForValidFilters(char escapeSymbol, str`
`415`	`415`	`}`
`416`	`416`
`417`	`417`	`private static string CreateRegexExcludePattern(IEnumerable<string> filters, char escapeSymbol)`
`418`		`- //only look for module filters here, types will be filtered out when instrumenting`
	`418`	`+ //only look for module filters here, types will be filtered out when instrumenting`
	`419`	`+#pragma warning disable IDE0057 // Use range operator`
`419`	`420`	`=> CreateRegexPattern(filters, escapeSymbol, filter => filter.Substring(filter.IndexOf(']') + 1) == "*");`
	`421`	`+#pragma warning restore IDE0057 // Use range operator`
`420`	`422`
`421`	`423`	`private static string CreateRegexIncludePattern(IEnumerable<string> filters, char escapeSymbol) =>`
`422`	`424`	`CreateRegexPattern(filters, escapeSymbol);`
`423`	`425`
`424`	`426`	`private static string CreateRegexPattern(IEnumerable<string> filters, char escapeSymbol, Func<string, bool> filterPredicate = null)`
`425`	`427`	`{`
`426`	`428`	`IEnumerable<string> filteredFilters = filterPredicate != null ? filters.Where(filterPredicate) : filters;`
	`429`	`+#pragma warning disable IDE0057 // Use range operator`
`427`	`430`	`IEnumerable<string> regexPatterns = filteredFilters.Select(x =>`
`428`	`431`	`$"{escapeSymbol}{WildcardToRegex(x.Substring(1, x.IndexOf(']') - 1)).Trim('^', '$')}{escapeSymbol}");`
	`432`	`+#pragma warning restore IDE0057 // Use range operator`
`429`	`433`	`return string.Join("\|", regexPatterns);`
`430`	`434`	`}`
`431`	`435`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,9 @@`
`1`	`1`	`// Copyright (c) Toni Solarin-Sodara`
`2`	`2`	`// Licensed under the MIT license. See LICENSE file in the project root for full license information.`
`3`	`3`
	`4`	`+using System.Text.Encodings.Web;`
	`5`	`+using System.Text.Json;`
`4`	`6`	`using Coverlet.Core.Abstractions;`
`5`		`-using Newtonsoft.Json;`
`6`	`7`
`7`	`8`	`namespace Coverlet.Core.Reporters`
`8`	`9`	`{`
`@@ -16,7 +17,13 @@ internal class JsonReporter : IReporter`
`16`	`17`
`17`	`18`	`public string Report(CoverageResult result, ISourceRootTranslator _)`
`18`	`19`	`{`
`19`		`- return JsonConvert.SerializeObject(result.Modules, Formatting.Indented);`
	`20`	`+ var options = new JsonSerializerOptions`
	`21`	`+ {`
	`22`	`+ Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,`
	`23`	`+ IncludeFields = true,`
	`24`	`+ WriteIndented = true,`
	`25`	`+ };`
	`26`	`+ return JsonSerializer.Serialize(result.Modules, options);`
`20`	`27`	`}`
`21`	`28`	`}`
`22`	`29`	`}`