Skip to content

Commit ad09c0d

Browse files
GrahamTheCoderGrahamTheCoder
committed
R# remove redundant code (manually rejecting terrible choices on using statement "tidies")
1 parent d5ea247 commit ad09c0d

48 files changed

Lines changed: 258 additions & 225 deletions

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎CodeConverter/CSharp/AdditionalAssignment.cs‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
1-
using Microsoft.CodeAnalysis.CSharp.Syntax;
1+
using Microsoft.CodeAnalysis.CSharp;
2+
using Microsoft.CodeAnalysis.CSharp.Syntax;
23

34
namespace ICSharpCode.CodeConverter.CSharp;
45

@@ -15,7 +16,7 @@ public AdditionalAssignment(ExpressionSyntax lhs, ExpressionSyntax rhs)
1516

1617
public static StatementSyntax CreateAssignment(AdditionalAssignment additionalAssignment)
1718
{
18-
var assign = Microsoft.CodeAnalysis.CSharp.SyntaxFactory.AssignmentExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind.SimpleAssignmentExpression, additionalAssignment.LeftHandSide, additionalAssignment.RightHandSide);
19-
return Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ExpressionStatement(assign);
19+
var assign = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, additionalAssignment.LeftHandSide, additionalAssignment.RightHandSide);
20+
return SyntaxFactory.ExpressionStatement(assign);
2021
}
2122
}

‎CodeConverter/CSharp/CommonConversions.cs‎

Lines changed: 12 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -138,7 +138,7 @@ public bool ShouldPreferExplicitType(VBSyntax.ExpressionSyntax exp,
138138
equalsValueClauseSyntax = null;
139139
} else {
140140
var returnBlock = SyntaxFactory.Block(SyntaxFactory.ReturnStatement(adjustedInitializerExpr));
141-
_typeContext.PerScopeState.Hoist<HoistedParameterlessFunction>(new HoistedParameterlessFunction(GetInitialValueFunctionName(vbName), csTypeSyntax, returnBlock));
141+
_typeContext.PerScopeState.Hoist(new HoistedParameterlessFunction(GetInitialValueFunctionName(vbName), csTypeSyntax, returnBlock));
142142
equalsValueClauseSyntax = null;
143143
}
144144
} else {
@@ -213,7 +213,7 @@ private static TypeSyntax WithDeclarationNameCasing(TypeSyntax syntax, ITypeSymb
213213

214214
return syntax.ReplaceNodes(syntax.DescendantNodes().OfType<CSSyntax.IdentifierNameSyntax>(), (oldNode, n) =>
215215
{
216-
var originalName = originalNames.FirstOrDefault(on => string.Equals(@on, oldNode.ToString(), StringComparison.OrdinalIgnoreCase));
216+
var originalName = originalNames.FirstOrDefault(on => string.Equals(on, oldNode.ToString(), StringComparison.OrdinalIgnoreCase));
217217
return originalName != null ? SyntaxFactory.IdentifierName(originalName) : oldNode;
218218
});
219219
}
@@ -282,10 +282,10 @@ public SyntaxToken ConvertIdentifier(SyntaxToken id, bool isAttribute = false, S
282282
}
283283
var csId = CsEscapedIdentifier(text);
284284
return sourceTriviaMapKind == SourceTriviaMapKind.None ? csId : csId.WithSourceMappingFrom(id);
285-
} else {
286-
text = text.WithHalfWidthLatinCharacters();
287285
}
288286

287+
text = text.WithHalfWidthLatinCharacters();
288+
289289
return CsEscapedIdentifier(text);
290290
}
291291

@@ -551,7 +551,7 @@ public static CSSyntax.VariableDeclaratorSyntax CreateVariableDeclarator(string
551551
public async Task<(string, ExpressionSyntax extraArg)> GetParameterizedPropertyAccessMethodAsync(IOperation operation)
552552
{
553553
if (operation is IPropertyReferenceOperation pro && pro.Arguments.Any() &&
554-
!VBasic.VisualBasicExtensions.IsDefault(pro.Property)) {
554+
!VisualBasicExtensions.IsDefault(pro.Property)) {
555555
var isSetter = pro.Parent.Kind == OperationKind.SimpleAssignment && pro.Parent.Children.First() == pro;
556556
var extraArg = isSetter
557557
? await GetParameterizedSetterArgAsync(operation)
@@ -605,16 +605,18 @@ public static SyntaxToken GetMethodBlockBaseIdentifierForImplicitReturn(SyntaxNo
605605
{
606606
if (vbMethodBlock.Parent is VBSyntax.PropertyBlockSyntax pb) {
607607
return pb.PropertyStatement.Identifier;
608-
} else if (vbMethodBlock is VBSyntax.MethodBlockSyntax mb) {
608+
}
609+
610+
if (vbMethodBlock is VBSyntax.MethodBlockSyntax mb) {
609611
return mb.SubOrFunctionStatement.Identifier;
610-
} else {
611-
throw new NotImplementedException("MethodBlockBaseIdentifier " + VisualBasicExtensions.Kind(vbMethodBlock).ToString());
612612
}
613+
614+
throw new NotImplementedException("MethodBlockBaseIdentifier " + VisualBasicExtensions.Kind(vbMethodBlock));
613615
}
614616

615617
public static bool IsDefaultIndexer(SyntaxNode node)
616618
{
617-
return node is VBSyntax.PropertyStatementSyntax pss && pss.Modifiers.Any(m => SyntaxTokenExtensions.IsKind(m, Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.DefaultKeyword));
619+
return node is VBSyntax.PropertyStatementSyntax pss && pss.Modifiers.Any(m => SyntaxTokenExtensions.IsKind(m, SyntaxKind.DefaultKeyword));
618620
}
619621

620622

@@ -658,7 +660,7 @@ public ISymbol GetCsOriginalSymbolOrNull(ISymbol symbol)
658660

659661
public static ExpressionSyntax ThrowawayParameters(ExpressionSyntax invocable, int paramCount)
660662
{
661-
var names = Enumerable.Range(1, paramCount).Select<int, string>(i =>
663+
var names = Enumerable.Range(1, paramCount).Select(i =>
662664
new string(Enumerable.Repeat('_', i).ToArray())
663665
).ToArray();
664666
var parameters = CreateParameterList(names.Select(n => SyntaxFactory.Parameter(SyntaxFactory.Identifier(n))));

‎CodeConverter/CSharp/ExpressionNodeVisitor.cs‎

Lines changed: 27 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -181,9 +181,13 @@ private static string GetXElementMethodName(VBSyntax.XmlMemberAccessExpressionSy
181181
{
182182
if (node.Token2 == default(SyntaxToken)) {
183183
return "Elements";
184-
} else if (node.Token2.Text == "@") {
184+
}
185+
186+
if (node.Token2.Text == "@") {
185187
return "Attributes";
186-
} else if (node.Token2.Text == ".") {
188+
}
189+
190+
if (node.Token2.Text == ".") {
187191
return "Descendants";
188192
}
189193
throw new NotImplementedException($"Xml member access operator: '{node.Token1}{node.Token2}{node.Token3}'");
@@ -206,7 +210,9 @@ public override async Task<CSharpSyntaxNode> VisitXmlName(VBSyntax.XmlNameSyntax
206210
),
207211
SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(node.LocalName.Text))
208212
);
209-
} else if (_xmlImportContext.HasDefaultImport) {
213+
}
214+
215+
if (_xmlImportContext.HasDefaultImport) {
210216
return SyntaxFactory.BinaryExpression(
211217
SyntaxKind.AddExpression,
212218
SyntaxFactory.MemberAccessExpression(
@@ -216,9 +222,9 @@ public override async Task<CSharpSyntaxNode> VisitXmlName(VBSyntax.XmlNameSyntax
216222
),
217223
SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(node.LocalName.Text))
218224
);
219-
} else {
220-
return SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(node.LocalName.Text));
221225
}
226+
227+
return SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(node.LocalName.Text));
222228
}
223229

224230
public override async Task<CSharpSyntaxNode> VisitGetTypeExpression(VBasic.Syntax.GetTypeExpressionSyntax node)
@@ -551,7 +557,7 @@ private static SyntaxToken GetRefToken(RefKind refKind)
551557
return token;
552558
}
553559

554-
private RefConversion GetRefConversionType(VBSyntax.ArgumentSyntax node, VBSyntax.ArgumentListSyntax argList, System.Collections.Immutable.ImmutableArray<IParameterSymbol> parameters, out string argName, out RefKind refKind)
560+
private RefConversion GetRefConversionType(VBSyntax.ArgumentSyntax node, VBSyntax.ArgumentListSyntax argList, ImmutableArray<IParameterSymbol> parameters, out string argName, out RefKind refKind)
555561
{
556562
var parameter = node.IsNamed && node is VBSyntax.SimpleArgumentSyntax sas
557563
? parameters.FirstOrDefault(p => p.Name.Equals(sas.NameColonEquals.Name.Identifier.Text, StringComparison.OrdinalIgnoreCase))
@@ -573,7 +579,7 @@ private static AssignmentExpressionSyntax Assign(ExpressionSyntax left, Identifi
573579

574580
public override async Task<CSharpSyntaxNode> VisitNameOfExpression(VBasic.Syntax.NameOfExpressionSyntax node)
575581
{
576-
return SyntaxFactory.InvocationExpression(ValidSyntaxFactory.NameOf(), SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList<ArgumentSyntax>(SyntaxFactory.Argument(await node.Argument.AcceptAsync<ExpressionSyntax>(TriviaConvertingExpressionVisitor)))));
582+
return SyntaxFactory.InvocationExpression(ValidSyntaxFactory.NameOf(), SyntaxFactory.ArgumentList(SyntaxFactory.SingletonSeparatedList(SyntaxFactory.Argument(await node.Argument.AcceptAsync<ExpressionSyntax>(TriviaConvertingExpressionVisitor)))));
577583
}
578584

579585
public override async Task<CSharpSyntaxNode> VisitEqualsValue(VBasic.Syntax.EqualsValueSyntax node)
@@ -735,7 +741,7 @@ public override async Task<CSharpSyntaxNode> VisitTernaryConditionalExpression(V
735741
var expr = SyntaxFactory.ConditionalExpression(condition, whenTrue, whenFalse);
736742

737743

738-
if (node.Parent.IsKind(VBasic.SyntaxKind.Interpolation) || VbSyntaxNodeExtensions.PrecedenceCouldChange(node))
744+
if (node.Parent.IsKind(VBasic.SyntaxKind.Interpolation) || node.PrecedenceCouldChange())
739745
return SyntaxFactory.ParenthesizedExpression(expr);
740746

741747
return expr;
@@ -780,9 +786,13 @@ private async Task<ExpressionSyntax> NegateAndSimplifyOrNullAsync(VBSyntax.Unary
780786
{
781787
if (await _operatorConverter.ConvertReferenceOrNothingComparisonOrNullAsync(node.Operand.SkipIntoParens(), true) is { } nothingComparison) {
782788
return nothingComparison;
783-
} else if (operandConvertedType.GetNullableUnderlyingType()?.SpecialType == SpecialType.System_Boolean) {
789+
}
790+
791+
if (operandConvertedType.GetNullableUnderlyingType()?.SpecialType == SpecialType.System_Boolean) {
784792
return SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, expr, LiteralConversions.GetLiteralExpression(false));
785-
} else if (expr is BinaryExpressionSyntax eq && eq.OperatorToken.IsKind(SyntaxKind.EqualsEqualsToken, SyntaxKind.ExclamationEqualsToken)){
793+
}
794+
795+
if (expr is BinaryExpressionSyntax eq && eq.OperatorToken.IsKind(SyntaxKind.EqualsEqualsToken, SyntaxKind.ExclamationEqualsToken)){
786796
return eq.WithOperatorToken(SyntaxFactory.Token(eq.OperatorToken.IsKind(SyntaxKind.ExclamationEqualsToken) ? SyntaxKind.EqualsEqualsToken : SyntaxKind.ExclamationEqualsToken));
787797
}
788798

@@ -976,7 +986,7 @@ private async Task<ExpressionSyntax> ConvertInvocationAsync(VBSyntax.InvocationE
976986
node.Expression is VBSyntax.MemberAccessExpressionSyntax maes)
977987
{
978988
var thisArgExpression = await maes.Expression.AcceptAsync<ExpressionSyntax>(TriviaConvertingExpressionVisitor);
979-
var thisArg = Microsoft.CodeAnalysis.CSharp.SyntaxFactory.Argument(thisArgExpression).WithRefKindKeyword(GetRefToken(RefKind.Ref));
989+
var thisArg = SyntaxFactory.Argument(thisArgExpression).WithRefKindKeyword(GetRefToken(RefKind.Ref));
980990
convertedArgumentList = SyntaxFactory.ArgumentList(SyntaxFactory.SeparatedList(convertedArgumentList.Arguments.Prepend(thisArg)));
981991
var containingType = (ExpressionSyntax) CommonConversions.CsSyntaxGenerator.TypeExpression(invocationSymbol.ContainingType);
982992
convertedExpression = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, containingType,
@@ -1440,7 +1450,7 @@ public override async Task<CSharpSyntaxNode> VisitQualifiedName(VBasic.Syntax.Qu
14401450
}
14411451

14421452
return leftIsGlobal ? SyntaxFactory.AliasQualifiedName((IdentifierNameSyntax)lhsSyntax, rhsSyntax) :
1443-
(CSharpSyntaxNode)SyntaxFactory.QualifiedName((NameSyntax)qualifiedName, rhsSyntax);
1453+
SyntaxFactory.QualifiedName((NameSyntax)qualifiedName, rhsSyntax);
14441454
}
14451455

14461456
public override async Task<CSharpSyntaxNode> VisitGenericName(VBasic.Syntax.GenericNameSyntax node)
@@ -1659,9 +1669,9 @@ RefConversion GetRefConversion(VBSyntax.ExpressionSyntax expression)
16591669

16601670
if (isTypeMismatch) {
16611671
return RefConversion.PreAndPostAssignment;
1662-
} else {
1663-
return RefConversion.Inline;
16641672
}
1673+
1674+
return RefConversion.Inline;
16651675
}
16661676

16671677
return RefConversion.PreAssigment;
@@ -1822,7 +1832,9 @@ nodeSymbolInfo.ContainingSymbol is INamespaceOrTypeSymbol containingSymbol &&
18221832
var qualification =
18231833
CommonConversions.GetTypeSyntax(containingTypeSymbol);
18241834
return Qualify(qualification.ToString(), left);
1825-
} else if (nodeSymbolInfo.IsNamespace()) {
1835+
}
1836+
1837+
if (nodeSymbolInfo.IsNamespace()) {
18261838
// Turn partial namespace qualification into full namespace qualification
18271839
var qualification =
18281840
containingSymbol.ToCSharpDisplayString();

‎CodeConverter/CSharp/HandledEventsAnalyzer.cs‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -91,17 +91,17 @@ private async Task<bool> IsNeverWrittenOrOverriddenAsync(ISymbol symbol)
9191
return (CreateEventContainer(e.EventContainer, semanticModel), new EventDescriptor(e.EventMember, eventSymbol), HandlingMethod: methodSymbol);
9292
});
9393
}
94-
private HandledEventsAnalysis.EventContainer CreateEventContainer(Microsoft.CodeAnalysis.VisualBasic.Syntax.EventContainerSyntax p, SemanticModel semanticModel)
94+
private HandledEventsAnalysis.EventContainer CreateEventContainer(EventContainerSyntax p, SemanticModel semanticModel)
9595
{
9696
switch (p) {
9797
//For me, trying to use "MyClass" in a Handles expression is a syntax error. Events aren't overridable anyway so I'm not sure how this would get used.
98-
case Microsoft.CodeAnalysis.VisualBasic.Syntax.KeywordEventContainerSyntax kecs when kecs.Keyword.IsKind(Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.MyBaseKeyword):
98+
case KeywordEventContainerSyntax kecs when kecs.Keyword.IsKind(Microsoft.CodeAnalysis.VisualBasic.SyntaxKind.MyBaseKeyword):
9999
return new HandledEventsAnalysis.EventContainer(HandledEventsAnalysis.EventContainerKind.Base, null);
100-
case Microsoft.CodeAnalysis.VisualBasic.Syntax.KeywordEventContainerSyntax _:
100+
case KeywordEventContainerSyntax _:
101101
return new HandledEventsAnalysis.EventContainer(HandledEventsAnalysis.EventContainerKind.This, null);
102-
case Microsoft.CodeAnalysis.VisualBasic.Syntax.WithEventsEventContainerSyntax weecs:
102+
case WithEventsEventContainerSyntax weecs:
103103
return new HandledEventsAnalysis.EventContainer(HandledEventsAnalysis.EventContainerKind.Property, semanticModel.GetSymbolInfo(weecs).Symbol.Name);
104-
case Microsoft.CodeAnalysis.VisualBasic.Syntax.WithEventsPropertyEventContainerSyntax wepecs:
104+
case WithEventsPropertyEventContainerSyntax wepecs:
105105
return new HandledEventsAnalysis.EventContainer(HandledEventsAnalysis.EventContainerKind.Property, wepecs.Property.Identifier.Text);
106106
default:
107107
throw new ArgumentOutOfRangeException(nameof(p), p, $"Unrecognized event container: `{p}`");

‎CodeConverter/CSharp/IOperatorConverter.cs‎

Lines changed: 6 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,10 @@
1-
namespace ICSharpCode.CodeConverter.CSharp;
1+
using Microsoft.CodeAnalysis.CSharp.Syntax;
2+
using BinaryExpressionSyntax = Microsoft.CodeAnalysis.VisualBasic.Syntax.BinaryExpressionSyntax;
3+
4+
namespace ICSharpCode.CodeConverter.CSharp;
25

36
public interface IOperatorConverter
47
{
5-
Task<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> ConvertReferenceOrNothingComparisonOrNullAsync(Microsoft.CodeAnalysis.VisualBasic.Syntax.ExpressionSyntax exprNode, bool negateExpression = false);
6-
Task<Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax> ConvertRewrittenBinaryOperatorOrNullAsync(Microsoft.CodeAnalysis.VisualBasic.Syntax.BinaryExpressionSyntax node, bool inExpressionLambda = false);
8+
Task<ExpressionSyntax> ConvertReferenceOrNothingComparisonOrNullAsync(Microsoft.CodeAnalysis.VisualBasic.Syntax.ExpressionSyntax exprNode, bool negateExpression = false);
9+
Task<ExpressionSyntax> ConvertRewrittenBinaryOperatorOrNullAsync(BinaryExpressionSyntax node, bool inExpressionLambda = false);
710
}

‎CodeConverter/CSharp/KnownMethod.cs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
1-
using Microsoft.CodeAnalysis.CSharp.Syntax;
2-
using SyntaxFactory = Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
1+
using Microsoft.CodeAnalysis.CSharp;
2+
using Microsoft.CodeAnalysis.CSharp.Syntax;
33

44
namespace ICSharpCode.CodeConverter.CSharp;
55

‎CodeConverter/CSharp/LiteralConversions.cs‎

Lines changed: 6 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,7 @@
1-
using Microsoft.CodeAnalysis.CSharp;
2-
using ExpressionSyntax = Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax;
3-
using SyntaxFactory = Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
4-
using CSSyntaxKind = Microsoft.CodeAnalysis.CSharp.SyntaxKind;
1+
using System.Globalization;
2+
using Microsoft.CodeAnalysis.CSharp;
53
using Microsoft.CodeAnalysis.CSharp.Syntax;
4+
using CSSyntaxKind = Microsoft.CodeAnalysis.CSharp.SyntaxKind;
65

76
namespace ICSharpCode.CodeConverter.CSharp;
87

@@ -103,9 +102,9 @@ internal static string EscapeQuotes(string unquotedTextForUser, string valueText
103102
{
104103
if (isVerbatimString) {
105104
return EscapeVerbatimQuotes(valueTextForCompiler);
106-
} else {
107-
return unquotedTextForUser.Replace("\"\"", "\\\"");
108105
}
106+
107+
return unquotedTextForUser.Replace("\"\"", "\\\"");
109108
}
110109

111110
public static string EscapeVerbatimQuotes(string valueTextForCompiler)
@@ -150,7 +149,7 @@ private static (string textForUser, ExpressionSyntax MaybeFullExpression) Conver
150149
string hexValue = textForUser.Substring(2);
151150
textForUser = "0x" + hexValue;
152151

153-
int parsedHexValue = int.Parse(hexValue, System.Globalization.NumberStyles.HexNumber);
152+
int parsedHexValue = int.Parse(hexValue, NumberStyles.HexNumber);
154153

155154
// This is a very special case where for 8 digit hex strings, C# interprets them as unsigned ints, but VB interprets them as ints
156155
// This can lead to a compile error if assigned to an int in VB. So in a case like 0x91234567, we generate `int.MinValue + 0x11234567`

‎CodeConverter/CSharp/LocalVariableAnalyzer.cs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@ internal static class LocalVariableAnalyzer
88
{
99
public static async Task<HashSet<ILocalSymbol>> GetDescendantsToInlineInLoopAsync(this Solution solution, SemanticModel semanticModel, VisualBasicSyntaxNode methodNode)
1010
{
11-
var forEachControlVariables = await methodNode.DescendantNodes().OfType<VBSyntax.ForEachBlockSyntax>().SelectAsync(forEach => GetLoopVariablesToInlineAsync(solution, semanticModel, forEach));
11+
var forEachControlVariables = await methodNode.DescendantNodes().OfType<ForEachBlockSyntax>().SelectAsync(forEach => GetLoopVariablesToInlineAsync(solution, semanticModel, forEach));
1212
return new HashSet<ILocalSymbol>(forEachControlVariables.Where(f => f != null), SymbolEquivalenceComparer.Instance);
1313
}
1414

‎CodeConverter/CSharp/MethodBodyExecutableStatementVisitor.cs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -445,7 +445,7 @@ public override async Task<SyntaxList<StatementSyntax>> VisitExitStatement(VBSyn
445445
if (IsIterator) return SingleStatement(SyntaxFactory.YieldStatement(SyntaxKind.YieldBreakStatement));
446446

447447
if (!enclosingMethodInfo.ReturnsVoidOrAsyncTask()) {
448-
ExpressionSyntax expr = HasReturnVariable ? (ExpressionSyntax)ReturnVariable : SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression);
448+
ExpressionSyntax expr = HasReturnVariable ? ReturnVariable : SyntaxFactory.LiteralExpression(SyntaxKind.DefaultLiteralExpression);
449449
return SingleStatement(SyntaxFactory.ReturnStatement(expr));
450450
}
451451

@@ -524,9 +524,9 @@ private async Task<ElseClauseSyntax> ConvertElseClauseAsync(VBSyntax.ElseBlockSy
524524
if (csStatements.TryUnpackSingleStatement(out var stmt) && stmt.IsKind(SyntaxKind.IfStatement)) {
525525
// so that you get a neat "else if" at the end
526526
return SyntaxFactory.ElseClause(stmt);
527-
} else {
528-
return SyntaxFactory.ElseClause(SyntaxFactory.Block(csStatements));
529527
}
528+
529+
return SyntaxFactory.ElseClause(SyntaxFactory.Block(csStatements));
530530
}
531531

532532
private async Task<StatementSyntax[]> ConvertStatementsAsync(SyntaxList<VBSyntax.StatementSyntax> statementSyntaxs)

0 commit comments

Comments
 (0)