Skip to content

Commit d50f66a

Browse files
pdelvopdelvo
committed
Fix that SA1115 is reported on multi-line parameters/arguments. Also remove dublicated code
1 parent c219678 commit d50f66a

2 files changed

Lines changed: 72 additions & 121 deletions

File tree

‎StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1115UnitTests.cs‎

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1244,6 +1244,32 @@ public void TestMethod()
12441244
await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
12451245
}
12461246

1247+
[Fact]
1248+
public async Task TestMethodArgumentsWithAttributeAsync()
1249+
{
1250+
var testCode = @"
1251+
[System.AttributeUsage(System.AttributeTargets.Parameter, AllowMultiple = true)]
1252+
public class MyAttribute : System.Attribute
1253+
{
1254+
}
1255+
1256+
class Foo
1257+
{
1258+
public static void DoWork(
1259+
[MyAttribute]
1260+
string param1,
1261+
[MyAttribute]
1262+
string param2,
1263+
[MyAttribute]
1264+
string param3,
1265+
[MyAttribute]
1266+
string param4)
1267+
{
1268+
}
1269+
}";
1270+
await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
1271+
}
1272+
12471273
protected override IEnumerable<DiagnosticAnalyzer> GetCSharpDiagnosticAnalyzers()
12481274
{
12491275
yield return new SA1115ParameterMustFollowComma();

‎StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1115ParameterMustFollowComma.cs‎

Lines changed: 46 additions & 121 deletions
Original file line numberDiff line numberDiff line change
@@ -103,91 +103,52 @@ private static void HandleImplicitElementAccess(SyntaxNodeAnalysisContext contex
103103
{
104104
var implicitElementAccess = (ImplicitElementAccessSyntax)context.Node;
105105

106-
AnalyzeArgumentList(context, implicitElementAccess.ArgumentList);
106+
if (implicitElementAccess.ArgumentList != null)
107+
{
108+
AnalyzeSyntaxList(context, implicitElementAccess.ArgumentList.Arguments);
109+
}
107110
}
108111

109112
private static void HandleElementBindingExpression(SyntaxNodeAnalysisContext context)
110113
{
111114
var elementBinding = (ElementBindingExpressionSyntax)context.Node;
112-
113-
AnalyzeArgumentList(context, elementBinding.ArgumentList);
115+
AnalyzeSyntaxList(context, elementBinding.ArgumentList.Arguments);
114116
}
115117

116118
private static void HandleConstructorInitializer(SyntaxNodeAnalysisContext context)
117119
{
118120
var constructorInitializer = (ConstructorInitializerSyntax)context.Node;
119-
120-
AnalyzeArgumentList(context, constructorInitializer.ArgumentList);
121+
AnalyzeSyntaxList(context, constructorInitializer.ArgumentList.Arguments);
121122
}
122123

123124
private static void HandleDelegateDeclaration(SyntaxNodeAnalysisContext context)
124125
{
125126
var delegateDeclaration = (DelegateDeclarationSyntax)context.Node;
126-
127-
AnalyzeParameterList(context, delegateDeclaration.ParameterList);
127+
AnalyzeSyntaxList(context, delegateDeclaration.ParameterList.Parameters);
128128
}
129129

130130
private static void HandleParenthesizedLambdaExpression(SyntaxNodeAnalysisContext context)
131131
{
132132
var lambda = (ParenthesizedLambdaExpressionSyntax)context.Node;
133-
134-
AnalyzeParameterList(context, lambda.ParameterList);
133+
AnalyzeSyntaxList(context, lambda.ParameterList.Parameters);
135134
}
136135

137136
private static void HandleAnonymousMethodExpression(SyntaxNodeAnalysisContext context)
138137
{
139138
var anonymousMethod = (AnonymousMethodExpressionSyntax)context.Node;
140-
141-
AnalyzeParameterList(context, anonymousMethod.ParameterList);
139+
AnalyzeSyntaxList(context, anonymousMethod.ParameterList?.Parameters ?? default(SeparatedSyntaxList<ParameterSyntax>));
142140
}
143141

144142
private static void HandleAttributeList(SyntaxNodeAnalysisContext context)
145143
{
146144
var attributeList = (AttributeListSyntax)context.Node;
147-
148-
if (attributeList.Attributes.Count < 2)
149-
{
150-
return;
151-
}
152-
153-
var previousLine = attributeList.Attributes[0].GetLineSpan().EndLinePosition.Line;
154-
for (int i = 1; i < attributeList.Attributes.Count; i++)
155-
{
156-
var currentAttribute = attributeList.Attributes[i];
157-
var lineSpan = currentAttribute.GetLineSpan();
158-
var currentLine = lineSpan.StartLinePosition.Line;
159-
if (currentLine - previousLine > 1)
160-
{
161-
context.ReportDiagnostic(Diagnostic.Create(Descriptor, currentAttribute.GetLocation()));
162-
}
163-
164-
previousLine = lineSpan.EndLinePosition.Line;
165-
}
145+
AnalyzeSyntaxList(context, attributeList.Attributes);
166146
}
167147

168148
private static void HandleAttribute(SyntaxNodeAnalysisContext context)
169149
{
170150
var attribute = (AttributeSyntax)context.Node;
171-
172-
if (attribute.ArgumentList == null
173-
|| attribute.ArgumentList.Arguments.Count < 2)
174-
{
175-
return;
176-
}
177-
178-
var previousLine = attribute.ArgumentList.Arguments[0].GetLineSpan().EndLinePosition.Line;
179-
for (int i = 1; i < attribute.ArgumentList.Arguments.Count; i++)
180-
{
181-
var currentArgument = attribute.ArgumentList.Arguments[i];
182-
var lineSpan = currentArgument.GetLineSpan();
183-
var currentLine = lineSpan.StartLinePosition.Line;
184-
if (currentLine - previousLine > 1)
185-
{
186-
context.ReportDiagnostic(Diagnostic.Create(Descriptor, currentArgument.GetLocation()));
187-
}
188-
189-
previousLine = lineSpan.EndLinePosition.Line;
190-
}
151+
AnalyzeSyntaxList(context, attribute.ArgumentList?.Arguments ?? default(SeparatedSyntaxList<AttributeArgumentSyntax>));
191152
}
192153

193154
private static void HandleArrayCreationExpression(SyntaxNodeAnalysisContext context)
@@ -200,128 +161,92 @@ private static void HandleArrayCreationExpression(SyntaxNodeAnalysisContext cont
200161

201162
foreach (var rankSpecifier in arrayCreation.Type.RankSpecifiers)
202163
{
203-
if (rankSpecifier.Sizes.Count < 2)
204-
{
205-
continue;
206-
}
207-
208-
var previousLine = rankSpecifier.Sizes[0].GetLineSpan().EndLinePosition.Line;
209-
for (int i = 1; i < rankSpecifier.Sizes.Count; i++)
210-
{
211-
var currentSize = rankSpecifier.Sizes[i];
212-
var lineSpan = currentSize.GetLineSpan();
213-
var currentLine = lineSpan.StartLinePosition.Line;
214-
if (currentLine - previousLine > 1)
215-
{
216-
context.ReportDiagnostic(Diagnostic.Create(Descriptor, currentSize.GetLocation()));
217-
}
218-
219-
previousLine = lineSpan.EndLinePosition.Line;
220-
}
164+
AnalyzeSyntaxList(context, rankSpecifier.Sizes);
221165
}
222166
}
223167

224168
private static void HandleElementAccessExpression(SyntaxNodeAnalysisContext context)
225169
{
226170
var elementAccess = (ElementAccessExpressionSyntax)context.Node;
227171

228-
AnalyzeArgumentList(context, elementAccess.ArgumentList);
172+
if (elementAccess.ArgumentList != null)
173+
{
174+
AnalyzeSyntaxList(context, elementAccess.ArgumentList.Arguments);
175+
}
229176
}
230177

231178
private static void HandleIndexerDeclaration(SyntaxNodeAnalysisContext context)
232179
{
233180
var indexerDeclaration = (IndexerDeclarationSyntax)context.Node;
234181

235-
AnalyzeParameterList(context, indexerDeclaration.ParameterList);
182+
if (indexerDeclaration.ParameterList != null)
183+
{
184+
AnalyzeSyntaxList(context, indexerDeclaration.ParameterList.Parameters);
185+
}
236186
}
237187

238188
private static void HandleObjectCreationExpression(SyntaxNodeAnalysisContext context)
239189
{
240190
var objectCreation = (ObjectCreationExpressionSyntax)context.Node;
241191

242-
AnalyzeArgumentList(context, objectCreation.ArgumentList);
192+
if (objectCreation.ArgumentList != null)
193+
{
194+
AnalyzeSyntaxList(context, objectCreation.ArgumentList.Arguments);
195+
}
243196
}
244197

245198
private static void HandleInvocationExpression(SyntaxNodeAnalysisContext context)
246199
{
247200
var invocation = (InvocationExpressionSyntax)context.Node;
248201

249-
AnalyzeArgumentList(context, invocation.ArgumentList);
202+
if (invocation.ArgumentList != null)
203+
{
204+
AnalyzeSyntaxList(context, invocation.ArgumentList.Arguments);
205+
}
250206
}
251207

252208
private static void HandleBaseMethodDeclaration(SyntaxNodeAnalysisContext context)
253209
{
254210
var constructorDeclaration = (BaseMethodDeclarationSyntax)context.Node;
255211

256-
AnalyzeParameterList(context, constructorDeclaration.ParameterList);
257-
}
258-
259-
private static void AnalyzeArgumentList(SyntaxNodeAnalysisContext context, BaseArgumentListSyntax argumentListSyntax)
260-
{
261-
if (argumentListSyntax == null
262-
|| argumentListSyntax.Arguments.Count < 2)
212+
if (constructorDeclaration.ParameterList != null)
263213
{
264-
return;
265-
}
266-
267-
var previousArgumentLine = argumentListSyntax.Arguments[0].GetLineSpan().EndLinePosition.Line;
268-
for (int i = 1; i < argumentListSyntax.Arguments.Count; i++)
269-
{
270-
var currentArgument = argumentListSyntax.Arguments[i];
271-
int currentArgumentStartLine;
272-
int currentArgumentEndLine;
273-
274-
if (currentArgument.HasLeadingTrivia && IsValidTrivia(currentArgument.GetLeadingTrivia()))
275-
{
276-
var lineSpan = currentArgument.SyntaxTree.GetLineSpan(currentArgument.FullSpan);
277-
currentArgumentStartLine = lineSpan.StartLinePosition.Line;
278-
currentArgumentEndLine = lineSpan.EndLinePosition.Line;
279-
}
280-
else
281-
{
282-
var lineSpan = currentArgument.GetLineSpan();
283-
currentArgumentStartLine = lineSpan.StartLinePosition.Line;
284-
currentArgumentEndLine = lineSpan.EndLinePosition.Line;
285-
}
286-
287-
if (currentArgumentStartLine - previousArgumentLine > 1)
288-
{
289-
context.ReportDiagnostic(Diagnostic.Create(Descriptor, currentArgument.GetLocation()));
290-
}
291-
292-
previousArgumentLine = currentArgumentEndLine;
214+
AnalyzeSyntaxList(context, constructorDeclaration.ParameterList.Parameters);
293215
}
294216
}
295217

296-
private static void AnalyzeParameterList(SyntaxNodeAnalysisContext context, BaseParameterListSyntax parameterListSyntax)
218+
private static void AnalyzeSyntaxList<TNode>(SyntaxNodeAnalysisContext context, SeparatedSyntaxList<TNode> syntaxList)
219+
where TNode : SyntaxNode
297220
{
298-
if (parameterListSyntax == null
299-
|| parameterListSyntax.Parameters.Count < 2)
221+
if (syntaxList.Count < 2)
300222
{
301223
return;
302224
}
303225

304-
var previousParameterLine = parameterListSyntax.Parameters[0].GetLineSpan().EndLinePosition.Line;
305-
for (int i = 1; i < parameterListSyntax.Parameters.Count; i++)
226+
var previousItemEndLine = syntaxList[0].GetLineSpan().EndLinePosition.Line;
227+
for (int i = 1; i < syntaxList.Count; i++)
306228
{
307-
var currentParameter = parameterListSyntax.Parameters[i];
308-
int currentParameterLine;
229+
var currentItem = syntaxList[i];
230+
FileLinePositionSpan currentSpan;
309231

310-
if (currentParameter.HasLeadingTrivia && IsValidTrivia(currentParameter.GetLeadingTrivia()))
232+
if (currentItem.HasLeadingTrivia && IsValidTrivia(currentItem.GetLeadingTrivia()))
311233
{
312-
currentParameterLine = currentParameter.SyntaxTree.GetLineSpan(currentParameter.FullSpan).StartLinePosition.Line;
234+
currentSpan = currentItem.SyntaxTree.GetLineSpan(currentItem.FullSpan);
313235
}
314236
else
315237
{
316-
currentParameterLine = currentParameter.GetLineSpan().StartLinePosition.Line;
238+
currentSpan = currentItem.GetLineSpan();
317239
}
318240

319-
if (currentParameterLine - previousParameterLine > 1)
241+
int currentItemStartLine = currentSpan.StartLinePosition.Line;
242+
var currentItemEndLine = currentSpan.EndLinePosition.Line;
243+
244+
if (currentItemStartLine - previousItemEndLine > 1)
320245
{
321-
context.ReportDiagnostic(Diagnostic.Create(Descriptor, currentParameter.GetLocation()));
246+
context.ReportDiagnostic(Diagnostic.Create(Descriptor, currentItem.GetLocation()));
322247
}
323248

324-
previousParameterLine = currentParameterLine;
249+
previousItemEndLine = currentItemEndLine;
325250
}
326251
}
327252

0 commit comments

Comments
 (0)