ran dotnet format for info severity

matracey · matracey · commit 1f4b081f6d93 · 2023-11-19T04:00:12.000-08:00
diff --git a/src/SystemTextJson.JsonDiffPatch/Diffs/DiffMatchPatch/DiffMatchPatch.cs b/src/SystemTextJson.JsonDiffPatch/Diffs/DiffMatchPatch/DiffMatchPatch.cs
diff --git a/src/SystemTextJson.JsonDiffPatch/Diffs/JsonDiffContext.cs b/src/SystemTextJson.JsonDiffPatch/Diffs/JsonDiffContext.cs
@@ -22,12 +22,9 @@ internal JsonDiffContext(JsonNode left, JsonNode right)
         /// <typeparam name="T">The type of left value.</typeparam>
         public T Left<T>()
         {
-            if (_leftNode is T leftValue)
-            {
-                return leftValue;
-            }
-
-            throw new InvalidOperationException($"Type must be '{nameof(JsonNode)}' or derived type.");
+            return _leftNode is T leftValue
+                ? leftValue
+                : throw new InvalidOperationException($"Type must be '{nameof(JsonNode)}' or derived type.");
         }
 
         /// <summary>
@@ -36,12 +33,9 @@ public T Left<T>()
         /// <typeparam name="T">The type of right value.</typeparam>
         public T Right<T>()
         {
-            if (_rightNode is T rightValue)
-            {
-                return rightValue;
-            }
-
-            throw new InvalidOperationException($"Type must be '{nameof(JsonNode)}' or derived type.");
+            return _rightNode is T rightValue
+                ? rightValue
+                : throw new InvalidOperationException($"Type must be '{nameof(JsonNode)}' or derived type.");
         }
     }
 }
diff --git a/src/SystemTextJson.JsonDiffPatch/Diffs/JsonDiffDelta.cs b/src/SystemTextJson.JsonDiffPatch/Diffs/JsonDiffDelta.cs
@@ -428,25 +428,19 @@ private static DeltaKind GetDeltaKind(JsonNode? delta)
 
             static DeltaKind GetDeltaKindFromJsonObject(JsonObject obj)
             {
-                if (obj.TryGetPropertyValue(TypePropertyName, out var typeParam) &&
+                return obj.TryGetPropertyValue(TypePropertyName, out var typeParam) &&
                     typeParam is JsonValue typeParamValue &&
                     typeParamValue.TryGetValue<string>(out var typeParamValueStr) &&
-                    string.Equals(ArrayType, typeParamValueStr, StringComparison.Ordinal))
-                {
-                    return DeltaKind.Array;
-                }
-
-                return DeltaKind.Object;
+                    string.Equals(ArrayType, typeParamValueStr, StringComparison.Ordinal)
+                    ? DeltaKind.Array
+                    : DeltaKind.Object;
             }
 
             static DeltaKind GetDeltaKindFromOpType(JsonValue opType)
             {
-                if (!opType.TryGetValue<int>(out var opTypeValue))
-                {
-                    return DeltaKind.None;
-                }
-
-                return opTypeValue switch
+                return !opType.TryGetValue<int>(out var opTypeValue)
+                    ? DeltaKind.None
+                    : opTypeValue switch
                 {
                     OpTypeDeleted => DeltaKind.Deleted,
                     OpTypeArrayMoved => DeltaKind.ArrayMove,
diff --git a/src/SystemTextJson.JsonDiffPatch/Diffs/JsonDiffPatcher.Array.cs b/src/SystemTextJson.JsonDiffPatch/Diffs/JsonDiffPatcher.Array.cs
@@ -214,12 +214,7 @@ internal static bool MatchArrayItem(ref ArrayItemMatchContext context, JsonDiffO
                 }
             }
 
-            if (options?.ArrayItemMatcher is not null)
-            {
-                return options.ArrayItemMatcher(ref context);
-            }
-
-            return false;
+            return options?.ArrayItemMatcher is not null ? options.ArrayItemMatcher(ref context) : false;
         }
 
         internal static bool MatchArrayValueItem(
@@ -235,12 +230,7 @@ internal static bool MatchArrayValueItem(
                 return true;
             }
 
-            if (options?.ArrayItemMatcher is not null)
-            {
-                return options.ArrayItemMatcher(ref context);
-            }
-
-            return false;
+            return options?.ArrayItemMatcher is not null ? options.ArrayItemMatcher(ref context) : false;
         }
 
         private static bool FallbackMatchArrayItem(ref ArrayItemMatchContext context, JsonDiffOptions options,
diff --git a/src/SystemTextJson.JsonDiffPatch/Diffs/JsonDiffPatcher.Diff.cs b/src/SystemTextJson.JsonDiffPatch/Diffs/JsonDiffPatcher.Diff.cs
@@ -208,12 +208,7 @@ static partial class JsonDiffPatcher
                 return formatter.Format(ref delta, left);
             }
 
-            if (delta.Document is TResult result)
-            {
-                return result;
-            }
-
-            return (TResult?)(object?)delta.Document;
+            return delta.Document is TResult result ? result : (TResult?)(object?)delta.Document;
         }
 
         private static void DiffInternal(
diff --git a/src/SystemTextJson.JsonDiffPatch/Diffs/Lcs.cs b/src/SystemTextJson.JsonDiffPatch/Diffs/Lcs.cs
@@ -149,21 +149,13 @@ public static Lcs Get(Span<JsonNode?> x, Span<JsonNode?> y, JsonDiffOptions? opt
                 for (var j = 1; j < n; j++)
                 {
                     var matchContext = new ArrayItemMatchContext(x[i - 1], i - 1, y[j - 1], j - 1);
-                    bool itemMatched;
-
-                    if (x[i - 1] is JsonValue && y[j - 1] is JsonValue)
-                    {
-                        itemMatched = JsonDiffPatcher.MatchArrayValueItem(ref matchContext,
+                    bool itemMatched = x[i - 1] is JsonValue && y[j - 1] is JsonValue
+                        ? JsonDiffPatcher.MatchArrayValueItem(ref matchContext,
                             ref wrapperCacheSpan[i - 1],
                             ref wrapperCacheSpan[x.Length + j - 1],
                             options,
-                            comparerOptions);
-                    }
-                    else
-                    {
-                        itemMatched = JsonDiffPatcher.MatchArrayItem(ref matchContext, options, comparerOptions);
-                    }
-
+                            comparerOptions)
+                        : JsonDiffPatcher.MatchArrayItem(ref matchContext, options, comparerOptions);
                     if (itemMatched)
                     {
                         matrix[i * n + j] = 1 + matrix[(i - 1) * n + (j - 1)];
diff --git a/src/SystemTextJson.JsonDiffPatch/JsonDiffPatcher.DeepEquals.cs b/src/SystemTextJson.JsonDiffPatch/JsonDiffPatcher.DeepEquals.cs
@@ -55,12 +55,9 @@ internal static bool DeepEquals(this JsonNode? left, JsonNode? right, in JsonCom
                 return true;
             }
 
-            if (left is null || right is null)
-            {
-                return false;
-            }
-
-            return left switch
+            return left is null || right is null
+                ? false
+                : left switch
             {
                 JsonValue val1 when right is JsonValue val2 => ValueEquals(val1, val2, comparerOptions),
                 JsonObject obj1 when right is JsonObject obj2 => ObjectEquals(obj1, obj2, comparerOptions),
@@ -83,12 +80,7 @@ public static bool DeepEquals(this JsonDocument? left, JsonDocument? right,
                 return true;
             }
 
-            if (left is null || right is null)
-            {
-                return false;
-            }
-
-            return left.RootElement.DeepEquals(right.RootElement, elementComparison);
+            return left is null || right is null ? false : left.RootElement.DeepEquals(right.RootElement, elementComparison);
         }
 
         /// <summary>
@@ -219,10 +211,7 @@ static void EnumerateProperty(in JsonElement element, out Dictionary<string, Jso
 
                 foreach (var property in element.EnumerateObject())
                 {
-                    if (properties is null)
-                    {
-                        properties = new Dictionary<string, JsonProperty>();
-                    }
+                    properties ??= new Dictionary<string, JsonProperty>();
 
                     properties[property.Name] = property;
                 }
@@ -286,12 +275,7 @@ private static bool ValueEquals(JsonValue x, JsonValue y, in JsonComparerOptions
                 var hash1 = valueComparer.GetHashCode(x);
                 var hash2 = valueComparer.GetHashCode(y);
 
-                if (hash1 != hash2)
-                {
-                    return false;
-                }
-
-                return valueComparer.Equals(x, y);
+                return hash1 != hash2 ? false : valueComparer.Equals(x, y);
             }
 
             var wrapperX = new JsonValueWrapper(x);
diff --git a/src/SystemTextJson.JsonDiffPatch/JsonNumber.cs b/src/SystemTextJson.JsonDiffPatch/JsonNumber.cs
@@ -211,24 +211,16 @@ public int CompareTo(ref JsonNumber another)
                 return GetDecimal().CompareTo(another.GetDecimal());
             }
 
-            if (DoubleValue.HasValue || FloatValue.HasValue ||
-                another.DoubleValue.HasValue || another.FloatValue.HasValue)
-            {
-                return JsonValueComparer.CompareDouble(GetDouble(), another.GetDouble());
-            }
-
-            return LongValue!.Value.CompareTo(another.LongValue!.Value);
+            return DoubleValue.HasValue || FloatValue.HasValue ||
+                another.DoubleValue.HasValue || another.FloatValue.HasValue
+                ? JsonValueComparer.CompareDouble(GetDouble(), another.GetDouble())
+                : LongValue!.Value.CompareTo(another.LongValue!.Value);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool RawTextEquals(ref JsonNumber another)
         {
-            if (!HasElement || HasElement != another.HasElement)
-            {
-                return false;
-            }
-
-            return string.Equals(Element.GetRawText(), another.Element.GetRawText());
+            return !HasElement || HasElement != another.HasElement ? false : string.Equals(Element.GetRawText(), another.Element.GetRawText());
         }
 
         public static bool TryGetJsonNumber(JsonValue jsonValue, out JsonNumber result)
diff --git a/src/SystemTextJson.JsonDiffPatch/JsonString.cs b/src/SystemTextJson.JsonDiffPatch/JsonString.cs
@@ -335,12 +335,7 @@ public bool Equals(ref JsonString another)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public bool ValueEquals(ref JsonString another)
         {
-            if (!HasElement || HasElement != another.HasElement)
-            {
-                return false;
-            }
-
-            return Element.ValueEquals(another.Element.GetString());
+            return !HasElement || HasElement != another.HasElement ? false : Element.ValueEquals(another.Element.GetString());
         }
 
         public static bool TryGetJsonString(JsonValue jsonValue, out JsonString result)
diff --git a/src/SystemTextJson.JsonDiffPatch/JsonValueComparer.Number.cs b/src/SystemTextJson.JsonDiffPatch/JsonValueComparer.Number.cs
@@ -14,10 +14,7 @@ private static bool AreDoubleClose(double x, double y)
             var tolerance = (Math.Abs(x) + Math.Abs(y) + 10.0) * epsilon;
             var difference = x - y;
 
-            if (-tolerance < difference)
-                return tolerance > difference;
-
-            return false;
+            return -tolerance < difference ? tolerance > difference : false;
         }
 
         internal static int CompareDouble(double x, double y)
diff --git a/src/SystemTextJson.JsonDiffPatch/JsonValueWrapper.cs b/src/SystemTextJson.JsonDiffPatch/JsonValueWrapper.cs
@@ -42,12 +42,7 @@ public bool DeepEquals(ref JsonValueWrapper another, in JsonComparerOptions comp
                 var hash1 = valueComparer.GetHashCode(Value);
                 var hash2 = valueComparer.GetHashCode(another.Value);
 
-                if (hash1 != hash2)
-                {
-                    return false;
-                }
-
-                return valueComparer.Equals(Value, another.Value);
+                return hash1 != hash2 ? false : valueComparer.Equals(Value, another.Value);
             }
 
             return DeepEquals(ref another, comparerOptions.JsonElementComparison);
@@ -104,31 +99,16 @@ public bool DeepEquals(ref JsonValueWrapper another, JsonElementComparison jsonE
 
         public int CompareTo(ref JsonValueWrapper another)
         {
-            if (ValueKind != another.ValueKind)
-            {
-                return -((int)ValueKind - (int)another.ValueKind);
-            }
-
-            switch (ValueKind)
+            return ValueKind != another.ValueKind
+                ? -((int)ValueKind - (int)another.ValueKind)
+                : ValueKind switch
             {
-                case JsonValueKind.Number:
-                    return NumberValue.CompareTo(ref another.NumberValue);
-
-                case JsonValueKind.String:
-                    return StringValue.CompareTo(ref another.StringValue);
-
-                case JsonValueKind.True:
-                case JsonValueKind.False:
-                    return 0;
-
-                case JsonValueKind.Null:
-                case JsonValueKind.Undefined:
-                case JsonValueKind.Object:
-                case JsonValueKind.Array:
-                default:
-                    throw new ArgumentOutOfRangeException(
-                        nameof(ValueKind), $"Unexpected value kind {ValueKind:G}");
-            }
+                JsonValueKind.Number => NumberValue.CompareTo(ref another.NumberValue),
+                JsonValueKind.String => StringValue.CompareTo(ref another.StringValue),
+                JsonValueKind.True or JsonValueKind.False => 0,
+                _ => throw new ArgumentOutOfRangeException(
+                                        nameof(ValueKind), $"Unexpected value kind {ValueKind:G}"),
+            };
         }
     }
 }
diff --git a/src/SystemTextJson.JsonDiffPatch/Patching/JsonDiffPatcher.Text.cs b/src/SystemTextJson.JsonDiffPatch/Patching/JsonDiffPatcher.Text.cs
@@ -21,12 +21,7 @@ static string DefaultLongTextPatch(string text, string patchText)
                 var patches = alg.patch_fromText(patchText);
                 var results = alg.patch_apply(patches, text);
 
-                if (((bool[])results[1]).Any(flag => !flag))
-                {
-                    throw new InvalidOperationException(TextPatchFailed);
-                }
-
-                return (string)results[0];
+                return ((bool[])results[1]).Any(flag => !flag) ? throw new InvalidOperationException(TextPatchFailed) : (string)results[0];
             }
         }
 
@@ -56,12 +51,7 @@ static string DefaultLongTextReversePatch(string text, string patchText)
 
                 var results = alg.patch_apply(reversedPatches, text);
 
-                if (((bool[])results[1]).Any(flag => !flag))
-                {
-                    throw new InvalidOperationException(TextPatchFailed);
-                }
-
-                return (string)results[0];
+                return ((bool[])results[1]).Any(flag => !flag) ? throw new InvalidOperationException(TextPatchFailed) : (string)results[0];
             }
         }
     }
diff --git a/test/SystemTextJson.JsonDiffPatch.Benchmark/BenchmarkHelper.cs b/test/SystemTextJson.JsonDiffPatch.Benchmark/BenchmarkHelper.cs
@@ -31,13 +31,8 @@ public static JsonDiffOptions CreateDiffOptionsWithJsonNetMatch()
         // https://github.com/wbish/jsondiffpatch.net/blob/master/Src/JsonDiffPatchDotNet/Lcs.cs#L51
         private static bool JsonNetArrayItemMatch(ref ArrayItemMatchContext context)
         {
-            if (context.Left is JsonObject && context.Right is JsonObject ||
-                context.Left is JsonArray && context.Right is JsonArray)
-            {
-                return true;
-            }
-
-            return false;
+            return context.Left is JsonObject && context.Right is JsonObject ||
+                context.Left is JsonArray && context.Right is JsonArray;
         }
     }
 }
diff --git a/test/SystemTextJson.JsonDiffPatch.UnitTests/DemoFileTests.cs b/test/SystemTextJson.JsonDiffPatch.UnitTests/DemoFileTests.cs
@@ -35,13 +35,10 @@ public void Diff_DemoJson()
                     // https://github.com/benjamine/jsondiffpatch/blob/a8cde4c666a8a25d09d8f216c7f19397f2e1b569/docs/demo/demo.js#L163
                     ArrayObjectItemKeyFinder = (n, i) =>
                     {
-                        if (n is JsonObject obj
-                            && obj.TryGetPropertyValue("name", out var value))
-                        {
-                            return value?.GetValue<string>() ?? "";
-                        }
-
-                        return null;
+                        return n is JsonObject obj
+                            && obj.TryGetPropertyValue("name", out var value)
+                            ? value?.GetValue<string>() ?? ""
+                            : (object?)null;
                     }
                 });
             sw.Stop();

Original file line number	Diff line number	Diff line change
`@@ -22,12 +22,9 @@ internal JsonDiffContext(JsonNode left, JsonNode right)`
`22`	`22`	`/// <typeparam name="T">The type of left value.</typeparam>`
`23`	`23`	`public T Left<T>()`
`24`	`24`	`{`
`25`		`- if (_leftNode is T leftValue)`
`26`		`- {`
`27`		`- return leftValue;`
`28`		`- }`
`29`		`-`
`30`		`- throw new InvalidOperationException($"Type must be '{nameof(JsonNode)}' or derived type.");`
	`25`	`+ return _leftNode is T leftValue`
	`26`	`+ ? leftValue`
	`27`	`+ : throw new InvalidOperationException($"Type must be '{nameof(JsonNode)}' or derived type.");`
`31`	`28`	`}`
`32`	`29`
`33`	`30`	`/// <summary>`
`@@ -36,12 +33,9 @@ public T Left<T>()`
`36`	`33`	`/// <typeparam name="T">The type of right value.</typeparam>`
`37`	`34`	`public T Right<T>()`
`38`	`35`	`{`
`39`		`- if (_rightNode is T rightValue)`
`40`		`- {`
`41`		`- return rightValue;`
`42`		`- }`
`43`		`-`
`44`		`- throw new InvalidOperationException($"Type must be '{nameof(JsonNode)}' or derived type.");`
	`36`	`+ return _rightNode is T rightValue`
	`37`	`+ ? rightValue`
	`38`	`+ : throw new InvalidOperationException($"Type must be '{nameof(JsonNode)}' or derived type.");`
`45`	`39`	`}`
`46`	`40`	`}`
`47`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -214,12 +214,7 @@ internal static bool MatchArrayItem(ref ArrayItemMatchContext context, JsonDiffO`
`214`	`214`	`}`
`215`	`215`	`}`
`216`	`216`
`217`		`- if (options?.ArrayItemMatcher is not null)`
`218`		`- {`
`219`		`- return options.ArrayItemMatcher(ref context);`
`220`		`- }`
`221`		`-`
`222`		`- return false;`
	`217`	`+ return options?.ArrayItemMatcher is not null ? options.ArrayItemMatcher(ref context) : false;`
`223`	`218`	`}`
`224`	`219`
`225`	`220`	`internal static bool MatchArrayValueItem(`
`@@ -235,12 +230,7 @@ internal static bool MatchArrayValueItem(`
`235`	`230`	`return true;`
`236`	`231`	`}`
`237`	`232`
`238`		`- if (options?.ArrayItemMatcher is not null)`
`239`		`- {`
`240`		`- return options.ArrayItemMatcher(ref context);`
`241`		`- }`
`242`		`-`
`243`		`- return false;`
	`233`	`+ return options?.ArrayItemMatcher is not null ? options.ArrayItemMatcher(ref context) : false;`
`244`	`234`	`}`
`245`	`235`
`246`	`236`	`private static bool FallbackMatchArrayItem(ref ArrayItemMatchContext context, JsonDiffOptions options,`
Original file line number	Diff line number	Diff line change
`@@ -208,12 +208,7 @@ static partial class JsonDiffPatcher`
`208`	`208`	`return formatter.Format(ref delta, left);`
`209`	`209`	`}`
`210`	`210`
`211`		`- if (delta.Document is TResult result)`
`212`		`- {`
`213`		`- return result;`
`214`		`- }`
`215`		`-`
`216`		`- return (TResult?)(object?)delta.Document;`
	`211`	`+ return delta.Document is TResult result ? result : (TResult?)(object?)delta.Document;`
`217`	`212`	`}`
`218`	`213`
`219`	`214`	`private static void DiffInternal(`
Original file line number	Diff line number	Diff line change
`@@ -335,12 +335,7 @@ public bool Equals(ref JsonString another)`
`335`	`335`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`336`	`336`	`public bool ValueEquals(ref JsonString another)`
`337`	`337`	`{`
`338`		`- if (!HasElement \|\| HasElement != another.HasElement)`
`339`		`- {`
`340`		`- return false;`
`341`		`- }`
`342`		`-`
`343`		`- return Element.ValueEquals(another.Element.GetString());`
	`338`	`+ return !HasElement \|\| HasElement != another.HasElement ? false : Element.ValueEquals(another.Element.GetString());`
`344`	`339`	`}`
`345`	`340`
`346`	`341`	`public static bool TryGetJsonString(JsonValue jsonValue, out JsonString result)`