From a3852a670673794e19fc367582159bcab1b5eba3 Mon Sep 17 00:00:00 2001 From: Ralf Koban Date: Mon, 9 Sep 2024 07:50:42 +0000 Subject: [PATCH 1/3] added more conditions --- ..._LogicalConditionsAreOnSameLineAnalyzer.cs | 62 +++++- ...calConditionsAreOnSameLineAnalyzerTests.cs | 185 ++++++++++++++++++ 2 files changed, 244 insertions(+), 3 deletions(-) diff --git a/MiKo.Analyzer.Shared/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer.cs b/MiKo.Analyzer.Shared/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer.cs index bc906667b..c83d2e970 100644 --- a/MiKo.Analyzer.Shared/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer.cs +++ b/MiKo.Analyzer.Shared/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer.cs @@ -14,6 +14,29 @@ public sealed class MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer : SpacingAn { SyntaxKind.LogicalAndExpression, SyntaxKind.LogicalOrExpression, + SyntaxKind.IsPatternExpression, + SyntaxKind.ParenthesizedExpression, + SyntaxKind.AddExpression, + SyntaxKind.SubtractExpression, + SyntaxKind.MultiplyExpression, + SyntaxKind.DivideExpression, + SyntaxKind.ModuloExpression, + SyntaxKind.LeftShiftExpression, + SyntaxKind.RightShiftExpression, + SyntaxKind.LogicalOrExpression, + SyntaxKind.LogicalAndExpression, + SyntaxKind.BitwiseOrExpression, + SyntaxKind.BitwiseAndExpression, + SyntaxKind.ExclusiveOrExpression, + SyntaxKind.EqualsExpression, + SyntaxKind.NotEqualsExpression, + SyntaxKind.LessThanExpression, + SyntaxKind.LessThanOrEqualExpression, + SyntaxKind.GreaterThanExpression, + SyntaxKind.GreaterThanOrEqualExpression, + SyntaxKind.IsExpression, + SyntaxKind.AsExpression, + SyntaxKind.CoalesceExpression, }; public MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer() : base(Id) @@ -29,7 +52,7 @@ private static bool IsOnSingleLineLocal(SyntaxNode s) return span.StartLinePosition.Line == span.EndLinePosition.Line; } - private static bool IsOnSingleLine(ExpressionSyntax syntax) + private static bool IsOnSingleLine(SyntaxNode syntax) { switch (syntax) { @@ -39,6 +62,9 @@ private static bool IsOnSingleLine(ExpressionSyntax syntax) case BinaryExpressionSyntax binary: return IsOnSingleLine(binary); + case IsPatternExpressionSyntax isPattern: + return IsOnSingleLine(isPattern); + default: return IsOnSingleLineLocal(syntax); } @@ -91,7 +117,37 @@ private static bool IsOnSingleLine(ParenthesizedExpressionSyntax parenthesized) return false; } - private static bool ShallAnalyzeNode(BinaryExpressionSyntax syntax) + private static bool IsOnSingleLine(IsPatternExpressionSyntax isPattern) + { + if (IsOnSingleLineLocal(isPattern)) + { + return true; + } + + var leftCondition = isPattern.Expression; + var rightCondition = isPattern.Pattern; + + var leftSpan = leftCondition.GetLocation().GetLineSpan(); + var rightSpan = rightCondition.GetLocation().GetLineSpan(); + + // let's see if both conditions are on same line + if (leftSpan.EndLinePosition.Line == rightSpan.StartLinePosition.Line) + { + if (leftSpan.StartLinePosition.Line == rightSpan.EndLinePosition.Line) + { + // both are on same line + return true; + } + + // at least one condition spans multiple lines + return false; + } + + // they span different lines + return IsOnSingleLine(leftCondition) && IsOnSingleLine(rightCondition); + } + + private static bool ShallAnalyzeNode(ExpressionSyntax syntax) { switch (syntax.Parent) { @@ -106,7 +162,7 @@ private static bool ShallAnalyzeNode(BinaryExpressionSyntax syntax) private void AnalyzeNode(SyntaxNodeAnalysisContext context) { - if (context.Node is BinaryExpressionSyntax syntax && ShallAnalyzeNode(syntax)) + if (context.Node is ExpressionSyntax syntax && ShallAnalyzeNode(syntax)) { if (IsOnSingleLine(syntax)) { diff --git a/MiKo.Analyzer.Tests/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzerTests.cs b/MiKo.Analyzer.Tests/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzerTests.cs index 7b2e14214..0c76b7e24 100644 --- a/MiKo.Analyzer.Tests/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzerTests.cs +++ b/MiKo.Analyzer.Tests/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzerTests.cs @@ -448,6 +448,191 @@ public class TestMe VerifyCSharpFix(OriginalCode, FixedCode); } + [TestCase("\r\n == null", "== null")] + [TestCase("== \r\n null", "== null")] + [TestCase("\r\n != null", "!= null")] + [TestCase("!= \r\n null", "!= null")] + [TestCase("\r\n is null", "is null")] + [TestCase("is \r\n null", "is null")] + [TestCase("\r\n is not null", "is not null")] + [TestCase("is \r\n not null", "is not null")] + [TestCase("is not \r\n null", "is not null")] + public void Code_gets_fixed_for_logical_condition_(string originalCondition, string fixedCondition) + { + const string Template = @" +using System; + +public class TestMe +{ + public object SomeProperty { get; set; } + + public void DoSomething(object o) + { + if (SomeProperty ###) + { } + } +} +"; + + VerifyCSharpFix(Template.Replace("###", originalCondition), Template.Replace("###", fixedCondition)); + } + + [Test] + public void Code_gets_fixed_if_logical_condition_with_equality_conditions_as_logical_parts_are_on_different_lines_1() + { + const string OriginalCode = @" +using System; + +public class TestMe +{ + public object SomeProperty { get; set; } + + public void DoSomething(object o) + { + if (SomeProperty != null + && SomeProperty.Equals(o)) + { } + } +} +"; + + const string FixedCode = @" +using System; + +public class TestMe +{ + public object SomeProperty { get; set; } + + public void DoSomething(object o) + { + if (SomeProperty != null && SomeProperty.Equals(o)) + { } + } + +} +"; + + VerifyCSharpFix(OriginalCode, FixedCode); + } + + [Test] + public void Code_gets_fixed_if_logical_condition_with_equality_conditions_as_logical_parts_are_on_different_lines_2() + { + const string OriginalCode = @" +using System; + +public class TestMe +{ + public object SomeProperty { get; set; } + + public void DoSomething(object o) + { + if (SomeProperty + != null + && SomeProperty.Equals(o)) + { } + } +} +"; + + const string FixedCode = @" +using System; + +public class TestMe +{ + public object SomeProperty { get; set; } + + public void DoSomething(object o) + { + if (SomeProperty != null && SomeProperty.Equals(o)) + { } + } + +} +"; + + VerifyCSharpFix(OriginalCode, FixedCode); + } + + [Test] + public void Code_gets_fixed_if_logical_condition_with_equality_conditions_as_logical_parts_are_on_different_lines_3() + { + const string OriginalCode = @" +using System; + +public class TestMe +{ + public object SomeProperty { get; set; } + + public void DoSomething(object o) + { + if (SomeProperty + != + null + && SomeProperty.Equals(o)) + { } + } +} +"; + + const string FixedCode = @" +using System; + +public class TestMe +{ + public object SomeProperty { get; set; } + + public void DoSomething(object o) + { + if (SomeProperty != null && SomeProperty.Equals(o)) + { } + } + +} +"; + + VerifyCSharpFix(OriginalCode, FixedCode); + } + + [Test] + public void Code_gets_fixed_if_logical_condition_with_equality_conditions_as_logical_parts_are_on_different_lines_4() + { + const string OriginalCode = @" +using System; + +public class TestMe +{ + public object SomeProperty { get; set; } + + public void DoSomething(object o) + { + if (SomeProperty != null + && SomeProperty + .Equals(o)) + { } + } +} +"; + + const string FixedCode = @" +using System; + +public class TestMe +{ + public object SomeProperty { get; set; } + + public void DoSomething(object o) + { + if (SomeProperty != null && SomeProperty.Equals(o)) + { } + } + +} +"; + + VerifyCSharpFix(OriginalCode, FixedCode); + } + //// TODO RKN: Add tests for inline-comments after condition parts protected override string GetDiagnosticId() => MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer.Id; From 46e03b5a531c72e7a46bab3c3ba8a0972a42411a Mon Sep 17 00:00:00 2001 From: Ralf Koban Date: Sat, 11 Oct 2025 11:21:35 +0000 Subject: [PATCH 2/3] Updated for patterns and if statements --- .../SyntaxNodeExtensions.Spacing.cs | 41 +++++++++++++++++-- .../Spacing/MiKo_6048_CodeFixProvider.cs | 3 +- ..._LogicalConditionsAreOnSameLineAnalyzer.cs | 4 +- ...calConditionsAreOnSameLineAnalyzerTests.cs | 4 -- 4 files changed, 40 insertions(+), 12 deletions(-) diff --git a/MiKo.Analyzer.Shared/Extensions/SyntaxNodeExtensions.Spacing.cs b/MiKo.Analyzer.Shared/Extensions/SyntaxNodeExtensions.Spacing.cs index adda369ba..bdae451b1 100644 --- a/MiKo.Analyzer.Shared/Extensions/SyntaxNodeExtensions.Spacing.cs +++ b/MiKo.Analyzer.Shared/Extensions/SyntaxNodeExtensions.Spacing.cs @@ -177,13 +177,13 @@ internal static T PlacedOnSameLine(this T value) where T : SyntaxNode case CasePatternSwitchLabelSyntax patternLabel: return PlacedOnSameLine(patternLabel) as T; case CaseSwitchLabelSyntax label: return PlacedOnSameLine(label) as T; case ConditionalExpressionSyntax conditional: return PlacedOnSameLine(conditional) as T; - case ConstantPatternSyntax constantPattern: return PlacedOnSameLine(constantPattern) as T; - case DeclarationPatternSyntax declaration: return PlacedOnSameLine(declaration) as T; + case IfStatementSyntax ifStatement: return PlacedOnSameLine(ifStatement) as T; case InvocationExpressionSyntax invocation: return PlacedOnSameLine(invocation) as T; case IsPatternExpressionSyntax pattern: return PlacedOnSameLine(pattern) as T; case MemberAccessExpressionSyntax maes: return PlacedOnSameLine(maes) as T; case NameSyntax name: return PlacedOnSameLine(name) as T; case ObjectCreationExpressionSyntax creation: return PlacedOnSameLine(creation) as T; + case PatternSyntax pattern: return PlacedOnSameLine(pattern) as T; case SingleVariableDesignationSyntax singleVariable: return PlacedOnSameLine(singleVariable) as T; case SwitchExpressionArmSyntax arm: return PlacedOnSameLine(arm) as T; case ThrowExpressionSyntax throwExpression: return PlacedOnSameLine(throwExpression) as T; @@ -235,6 +235,11 @@ internal static DeclarationPatternSyntax PlacedOnSameLine(this DeclarationPatter .WithType(value.Type.WithoutTrailingTrivia()) .WithDesignation(PlacedOnSameLine(value.Designation)); + internal static IfStatementSyntax PlacedOnSameLine(this IfStatementSyntax value) => value.WithIfKeyword(value.IfKeyword.WithTrailingSpace()) + .WithOpenParenToken(value.OpenParenToken.WithoutTrailingTrivia()) + .WithCondition(value.Condition.PlacedOnSameLine()) + .WithCloseParenToken(value.CloseParenToken.WithoutLeadingTrivia()); + internal static InvocationExpressionSyntax PlacedOnSameLine(this InvocationExpressionSyntax value) => value.WithoutTrivia() .WithExpression(PlacedOnSameLine(value.Expression)) .WithArgumentList(PlacedOnSameLine(value.ArgumentList)); @@ -279,6 +284,30 @@ internal static ObjectCreationExpressionSyntax PlacedOnSameLine(this ObjectCreat .WithArgumentList(PlacedOnSameLine(value.ArgumentList)) .WithInitializer(PlacedOnSameLine(value.Initializer)); + internal static PatternSyntax PlacedOnSameLine(this PatternSyntax value) + { + switch (value) + { + case ConstantPatternSyntax constantPattern: return PlacedOnSameLine(constantPattern); + case DeclarationPatternSyntax declaration: return PlacedOnSameLine(declaration); + case UnaryPatternSyntax unaryPattern: return PlacedOnSameLine(unaryPattern); + + /* + -> BinaryPatternSyntax + -> DiscardPatternSyntax + -> ListPatternSyntax + -> ParenthesizedPatternSyntax + -> RecursivePatternSyntax + -> RelationalPatternSyntax + -> SlicePatternSyntax + -> TypePatternSyntax + -> VarPatternSyntax + */ + default: + return value.WithoutTrivia(); + } + } + internal static SingleVariableDesignationSyntax PlacedOnSameLine(this SingleVariableDesignationSyntax value) => value.WithoutTrivia() .WithIdentifier(value.Identifier.WithoutTrivia()); @@ -297,9 +326,13 @@ internal static TypeArgumentListSyntax PlacedOnSameLine(this TypeArgumentListSyn .WithGreaterThanToken(value.GreaterThanToken.WithoutTrivia()) .WithLessThanToken(value.LessThanToken.WithoutTrivia()); + internal static UnaryPatternSyntax PlacedOnSameLine(this UnaryPatternSyntax value) => value.WithoutTrivia() + .WithOperatorToken(value.OperatorToken.WithLeadingSpace().WithoutTrailingTrivia()) + .WithPattern(PlacedOnSameLine(value.Pattern)); + internal static WhenClauseSyntax PlacedOnSameLine(this WhenClauseSyntax value) => value?.WithoutTrivia() - .WithWhenKeyword(value.WhenKeyword.WithLeadingSpace().WithoutTrailingTrivia()) - .WithCondition(PlacedOnSameLine(value.Condition)); + .WithWhenKeyword(value.WhenKeyword.WithLeadingSpace().WithoutTrailingTrivia()) + .WithCondition(PlacedOnSameLine(value.Condition)); /// /// Creates a new node from this node with additional leading trivia. diff --git a/MiKo.Analyzer.Shared/Rules/Spacing/MiKo_6048_CodeFixProvider.cs b/MiKo.Analyzer.Shared/Rules/Spacing/MiKo_6048_CodeFixProvider.cs index ed11de4f5..584154759 100644 --- a/MiKo.Analyzer.Shared/Rules/Spacing/MiKo_6048_CodeFixProvider.cs +++ b/MiKo.Analyzer.Shared/Rules/Spacing/MiKo_6048_CodeFixProvider.cs @@ -19,8 +19,7 @@ protected override SyntaxNode GetUpdatedSyntaxRoot(Document document, SyntaxNode { case IfStatementSyntax statement: { - var updated = statement.WithOpenParenToken(statement.OpenParenToken.WithoutTrailingTrivia()) - .WithCloseParenToken(statement.CloseParenToken.WithoutLeadingTrivia()); + var updated = statement.PlacedOnSameLine(); return root.ReplaceNode(statement, updated); } diff --git a/MiKo.Analyzer.Shared/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer.cs b/MiKo.Analyzer.Shared/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer.cs index c83d2e970..cdf332810 100644 --- a/MiKo.Analyzer.Shared/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer.cs +++ b/MiKo.Analyzer.Shared/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer.cs @@ -97,7 +97,7 @@ private static bool IsOnSingleLine(BinaryExpressionSyntax binary) } // they span different lines - return IsOnSingleLine(leftCondition) && IsOnSingleLine(rightCondition); + return false; } private static bool IsOnSingleLine(ParenthesizedExpressionSyntax parenthesized) @@ -144,7 +144,7 @@ private static bool IsOnSingleLine(IsPatternExpressionSyntax isPattern) } // they span different lines - return IsOnSingleLine(leftCondition) && IsOnSingleLine(rightCondition); + return false; } private static bool ShallAnalyzeNode(ExpressionSyntax syntax) diff --git a/MiKo.Analyzer.Tests/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzerTests.cs b/MiKo.Analyzer.Tests/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzerTests.cs index 0c76b7e24..1fba2281c 100644 --- a/MiKo.Analyzer.Tests/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzerTests.cs +++ b/MiKo.Analyzer.Tests/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzerTests.cs @@ -508,7 +508,6 @@ public void DoSomething(object o) if (SomeProperty != null && SomeProperty.Equals(o)) { } } - } "; @@ -547,7 +546,6 @@ public void DoSomething(object o) if (SomeProperty != null && SomeProperty.Equals(o)) { } } - } "; @@ -587,7 +585,6 @@ public void DoSomething(object o) if (SomeProperty != null && SomeProperty.Equals(o)) { } } - } "; @@ -626,7 +623,6 @@ public void DoSomething(object o) if (SomeProperty != null && SomeProperty.Equals(o)) { } } - } "; From 6bfacc0b965d21a9e0f9e3fd35dcb8e289dcc7ce Mon Sep 17 00:00:00 2001 From: Ralf Koban Date: Sat, 11 Oct 2025 11:48:21 +0000 Subject: [PATCH 3/3] Tests fixed, code reformatted, duplicate expressions removed as they caused multiple issues instead of a single one (resolves #1512) --- ..._LogicalConditionsAreOnSameLineAnalyzer.cs | 36 +++++++-------- ...calConditionsAreOnSameLineAnalyzerTests.cs | 45 ++++++++++++++++--- 2 files changed, 57 insertions(+), 24 deletions(-) diff --git a/MiKo.Analyzer.Shared/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer.cs b/MiKo.Analyzer.Shared/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer.cs index cdf332810..9450e87c3 100644 --- a/MiKo.Analyzer.Shared/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer.cs +++ b/MiKo.Analyzer.Shared/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer.cs @@ -12,31 +12,29 @@ public sealed class MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer : SpacingAn private static readonly SyntaxKind[] Expressions = { - SyntaxKind.LogicalAndExpression, - SyntaxKind.LogicalOrExpression, - SyntaxKind.IsPatternExpression, - SyntaxKind.ParenthesizedExpression, SyntaxKind.AddExpression, - SyntaxKind.SubtractExpression, - SyntaxKind.MultiplyExpression, - SyntaxKind.DivideExpression, - SyntaxKind.ModuloExpression, - SyntaxKind.LeftShiftExpression, - SyntaxKind.RightShiftExpression, - SyntaxKind.LogicalOrExpression, - SyntaxKind.LogicalAndExpression, - SyntaxKind.BitwiseOrExpression, + SyntaxKind.AsExpression, SyntaxKind.BitwiseAndExpression, - SyntaxKind.ExclusiveOrExpression, + SyntaxKind.BitwiseOrExpression, + SyntaxKind.CoalesceExpression, + SyntaxKind.DivideExpression, SyntaxKind.EqualsExpression, - SyntaxKind.NotEqualsExpression, - SyntaxKind.LessThanExpression, - SyntaxKind.LessThanOrEqualExpression, + SyntaxKind.ExclusiveOrExpression, SyntaxKind.GreaterThanExpression, SyntaxKind.GreaterThanOrEqualExpression, SyntaxKind.IsExpression, - SyntaxKind.AsExpression, - SyntaxKind.CoalesceExpression, + SyntaxKind.IsPatternExpression, + SyntaxKind.LeftShiftExpression, + SyntaxKind.LessThanExpression, + SyntaxKind.LessThanOrEqualExpression, + SyntaxKind.LogicalAndExpression, + SyntaxKind.LogicalOrExpression, + SyntaxKind.ModuloExpression, + SyntaxKind.MultiplyExpression, + SyntaxKind.NotEqualsExpression, + SyntaxKind.ParenthesizedExpression, + SyntaxKind.RightShiftExpression, + SyntaxKind.SubtractExpression, }; public MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer() : base(Id) diff --git a/MiKo.Analyzer.Tests/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzerTests.cs b/MiKo.Analyzer.Tests/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzerTests.cs index 1fba2281c..cf195ebab 100644 --- a/MiKo.Analyzer.Tests/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzerTests.cs +++ b/MiKo.Analyzer.Tests/Rules/Spacing/MiKo_6048_LogicalConditionsAreOnSameLineAnalyzerTests.cs @@ -26,7 +26,7 @@ public void DoSomething(bool flag1, bool flag2) "); [Test] - public void No_issue_is_reported_if_logical_condition_parts_are_all_on_their_own_line_with_condition_on_same_line_as_first() => No_issue_is_reported_for(@" + public void An_issue_is_reported_if_logical_condition_parts_are_all_on_their_own_line_with_condition_on_same_line_as_first() => An_issue_is_reported_for(@" using System; public class TestMe @@ -41,7 +41,7 @@ public void DoSomething(bool flag1, bool flag2) "); [Test] - public void No_issue_is_reported_if_logical_condition_parts_are_all_on_their_own_line_with_condition_on_same_line_as_last() => No_issue_is_reported_for(@" + public void An_issue_is_reported_if_logical_condition_parts_are_all_on_their_own_line_with_condition_on_same_line_as_last() => An_issue_is_reported_for(@" using System; public class TestMe @@ -56,7 +56,7 @@ public void DoSomething(bool flag1, bool flag2) "); [Test] - public void No_issue_is_reported_if_parenthesized_logical_condition_parts_are_all_on_their_own_line_and_combined_condition_is_first() => No_issue_is_reported_for(@" + public void An_issue_is_reported_if_parenthesized_logical_condition_parts_are_all_on_their_own_line_and_combined_condition_is_first() => An_issue_is_reported_for(@" using System; public class TestMe @@ -71,7 +71,7 @@ public void DoSomething(bool flag1, bool flag2, bool flag3) "); [Test] - public void No_issue_is_reported_if_parenthesized_logical_condition_parts_are_all_on_their_own_line_and_combined_condition_is_last() => No_issue_is_reported_for(@" + public void An_issue_is_reported_if_parenthesized_logical_condition_parts_are_all_on_their_own_line_and_combined_condition_is_last() => An_issue_is_reported_for(@" using System; public class TestMe @@ -86,7 +86,7 @@ public void DoSomething(bool flag1, bool flag2, bool flag3) "); [Test] - public void No_issue_is_reported_if_multiple_parenthesized_logical_condition_parts_are_all_on_multiple_lines() => No_issue_is_reported_for(@" + public void An_issue_is_reported_if_multiple_parenthesized_logical_condition_parts_are_all_on_multiple_lines() => An_issue_is_reported_for(@" using System; public class TestMe @@ -629,6 +629,41 @@ public void DoSomething(object o) VerifyCSharpFix(OriginalCode, FixedCode); } + [Test] + public void Code_gets_fixed_for_invocation_on_multiple_lines() + { + const string OriginalCode = """ + using System; + + public class TestMe + { + public void DoSomething(string someText) + { + if (!string.IsNullOrWhiteSpace(someText) && Enum.TryParse( + someText.Replace(" ", "", StringComparison.Ordinal), out var format)) + { + } + } + } + """; + + const string FixedCode = """ + using System; + + public class TestMe + { + public void DoSomething(string someText) + { + if (!string.IsNullOrWhiteSpace(someText) && Enum.TryParse(someText.Replace(" ", "", StringComparison.Ordinal), out var format)) + { + } + } + } + """; + + VerifyCSharpFix(OriginalCode, FixedCode); + } + //// TODO RKN: Add tests for inline-comments after condition parts protected override string GetDiagnosticId() => MiKo_6048_LogicalConditionsAreOnSameLineAnalyzer.Id;