change input format for contracts to jsonc

dotnet · lambdageek · Apr 19, 2024 · Mar 28, 2024 · Mar 28, 2024 · Apr 1, 2024
commit 2429bd81ddd95df86c7befa16c227ba35d4a0b1b
diff --git a/src/coreclr/debug/runtimeinfo/CMakeLists.txt b/src/coreclr/debug/runtimeinfo/CMakeLists.txt
@@ -57,7 +57,7 @@ if("${CDAC_BUILD_TOOL_BINARY_PATH}" STREQUAL "" OR NOT EXISTS "${CDAC_BUILD_TOOL
   message(FATAL_ERROR "No cdac-build-tool set or ${CDAC_BUILD_TOOL_BINARY_PATH} does not exist")
 endif()
 
-set(CONTRACT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/contracts.txt")
+set(CONTRACT_FILE "${CMAKE_CURRENT_SOURCE_DIR}/contracts.jsonc")
 
 # generate the contract descriptor by running cdac-build-tool
 # n.b. this just uses `dotnet` from the PATH.  InitializeDotNetCli adds the apropropriate directory

diff --git a/src/coreclr/debug/runtimeinfo/contracts.jsonc b/src/coreclr/debug/runtimeinfo/contracts.jsonc
@@ -0,0 +1,14 @@
+//algorithmic contracts for coreclr
+// The format of this file is: JSON with comments
+//  {
+//     "CONTRACT NAME": VERSION,
+//     ...
+//   }
+// CONTRACT NAME is an arbitrary string, VERSION is an integer
+//
+// cdac-build-tool can take multiple "-c contract_file" arguments
+// so to conditionally include contracts, put additional contracts in a separate file
+{
+  "SOSBreakingChangeVersion": 1 // example contract: "runtime exports an SOS breaking change version global"
+}
+
diff --git a/src/coreclr/debug/runtimeinfo/contracts.txt b/src/coreclr/debug/runtimeinfo/contracts.txt
diff --git a/src/coreclr/tools/cdac-build-tool/ContractReader.cs b/src/coreclr/tools/cdac-build-tool/ContractReader.cs
@@ -5,6 +5,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Diagnostics.Contracts;
 using System.IO;
+using System.Text.Json;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
@@ -15,35 +16,20 @@ public partial class ContractReader
 {
     private readonly DataDescriptorModel.Builder _builder;
 
+    private static readonly JsonSerializerOptions s_jsonSerializerOptions = new() { PropertyNameCaseInsensitive = false, ReadCommentHandling = JsonCommentHandling.Skip };
+
     public ContractReader(DataDescriptorModel.Builder builder)
     {
         _builder = builder;
     }
 
     public async Task<bool> ParseContracts(string contractFilePath, CancellationToken token = default)
     {
-        var s = File.OpenRead(contractFilePath);
-        using var reader = new StreamReader(s, System.Text.Encoding.UTF8);
-        uint lineNum = 0;
-        while (true)
-        {
-            var line = await reader.ReadLineAsync(token).ConfigureAwait(false);
-            lineNum++;
-            if (line == null)
-            {
-                break;
-            }
-            if (BlankOrCommentRegex().Match(line) is { Success: true })
-            {
-                continue;
-            }
-            if (!TryParseContractLine(line, out string? contract, out int version))
-            {
-                Console.Error.WriteLine($"{contractFilePath}:{lineNum}: Invalid contract line: {line}");
-                return false;
-            }
-            _builder.AddOrUpdateContract(contract, version);
-        }
+        string? contents = await File.ReadAllTextAsync(contractFilePath, token).ConfigureAwait(false);
+        var contractCollectionModel = JsonSerializer.Deserialize<DataDescriptorModel.ContractCollectionModel>(contents, s_jsonSerializerOptions);
+        if (contractCollectionModel is null)
+            return false;
+        _builder.AddOrupdateContracts(contractCollectionModel);
         return true;
     }
     public bool TryParseContractLine(string line, [NotNullWhen(true)] out string? contract, out int version)

diff --git a/src/coreclr/tools/cdac-build-tool/DataDescriptorModel.cs b/src/coreclr/tools/cdac-build-tool/DataDescriptorModel.cs
@@ -2,10 +2,12 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text.Json;
+using System.Text.Json.Serialization;
 
 namespace Microsoft.DotNet.Diagnostics.DataContract.BuildTool;
 
@@ -14,9 +16,9 @@ public class DataDescriptorModel
     public string Baseline { get; }
     public IReadOnlyDictionary<string, TypeModel> Types { get; }
     public IReadOnlyDictionary<string, GlobalModel> Globals { get; }
-    public IReadOnlyDictionary<string, ContractModel> Contracts { get; }
+    public ContractCollectionModel Contracts { get; }
     public uint PlatformFlags { get; }
-    private DataDescriptorModel(string baseline, IReadOnlyDictionary<string, TypeModel> types, IReadOnlyDictionary<string, GlobalModel> globals, IReadOnlyDictionary<string, ContractModel> contracts, uint platformFlags)
+    private DataDescriptorModel(string baseline, IReadOnlyDictionary<string, TypeModel> types, IReadOnlyDictionary<string, GlobalModel> globals, ContractCollectionModel contracts, uint platformFlags)
     {
         Baseline = baseline;
         Types = types;
@@ -131,12 +133,8 @@ public string ToJson()
                 }
             }
             w.WriteEndObject();
-            w.WriteStartObject("contracts");
-            foreach (var (contractName, contract) in Contracts)
-            {
-                w.WriteNumber(contractName, contract.Version);
-            }
-            w.WriteEndObject();
+            w.WritePropertyName("contracts");
+            JsonSerializer.Serialize(w, Contracts);
             w.WriteEndObject();
             w.Flush();
         }
@@ -202,6 +200,14 @@ public void AddOrUpdateContract(string name, int version)
             contract.Version = version;
         }
 
+        public void AddOrupdateContracts(IEnumerable<KeyValuePair<string, ContractModel>> contracts)
+        {
+            foreach (var (name, contract) in contracts)
+            {
+                AddOrUpdateContract(name, contract.Version);
+            }
+        }
+
         public void SetBaseline(string baseline)
         {
             if (_baseline != string.Empty && _baseline != baseline)
@@ -258,7 +264,7 @@ public DataDescriptorModel Build()
             {
                 contracts[contractName] = contractBuilder.Build();
             }
-            return new DataDescriptorModel(_baseline, types, globals, contracts, PlatformFlags);
+            return new DataDescriptorModel(_baseline, types, globals, new ContractCollectionModel(contracts), PlatformFlags);
         }
     }
 
@@ -409,6 +415,19 @@ public readonly struct GlobalModel
         public GlobalValue Value { get; init; }
     }
 
+    [JsonConverter(typeof(JsonConverter.ContractCollectionModelJsonConverter))]
+    public class ContractCollectionModel : IEnumerable<KeyValuePair<string, ContractModel>>
+    {
+        public IReadOnlyDictionary<string, ContractModel> Contracts { get; }
+        public ContractCollectionModel(IReadOnlyDictionary<string, ContractModel> contracts)
+        {
+            Contracts = contracts;
+        }
+
+        public IEnumerator<KeyValuePair<string, ContractModel>> GetEnumerator() => Contracts.GetEnumerator();
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+    }
+
     public readonly struct ContractModel
     {
         public int Version { get; init; }

diff --git a/src/coreclr/tools/cdac-build-tool/JsonConverter/ContractCollectctionModelJsonConverter.cs b/src/coreclr/tools/cdac-build-tool/JsonConverter/ContractCollectctionModelJsonConverter.cs
@@ -0,0 +1,62 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Microsoft.DotNet.Diagnostics.DataContract.BuildTool;
+
+namespace Microsoft.DotNet.Diagnostics.DataContract.JsonConverter;
+
+/// <summary>
+///  Parses or serializes contracts in the "compact" JSON format: as a single
+///  object for the whole collection where each contract name is a property name and
+///  the value is the version number.
+/// </summary>
+public class ContractCollectionModelJsonConverter : JsonConverter<DataDescriptorModel.ContractCollectionModel>
+{
+    public override DataDescriptorModel.ContractCollectionModel Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+    {
+        Dictionary<string, DataDescriptorModel.ContractBuilder> contracts = new();
+        if (reader.TokenType != JsonTokenType.StartObject)
+        {
+            throw new JsonException();
+        }
+        while (reader.Read())
+        {
+            switch (reader.TokenType)
+            {
+                case JsonTokenType.EndObject:
+                    var builtContracts = contracts.Select((kvp) => (kvp.Key, kvp.Value.Build()));
+                    return new DataDescriptorModel.ContractCollectionModel(builtContracts.ToDictionary());
+                case JsonTokenType.PropertyName:
+                    string? propertyName = reader.GetString();
+                    if (propertyName is null)
+                    {
+                        throw new JsonException();
+                    }
+                    reader.Read();
+                    int version = reader.GetInt32();
+                    contracts.Add(propertyName, new DataDescriptorModel.ContractBuilder { Version = version });
+                    break;
+                case JsonTokenType.Comment:
+                    break;
+                default:
+                    throw new JsonException();
+            }
+        }
+        throw new JsonException();
+    }
+
+    public override void Write(Utf8JsonWriter writer, DataDescriptorModel.ContractCollectionModel value, JsonSerializerOptions options)
+    {
+        writer.WriteStartObject();
+        foreach (var (name, contract) in value.Contracts)
+        {
+            writer.WriteNumber(name, contract.Version);
+
+        }
+        writer.WriteEndObject();
+    }
+}