Fix SA1503: Braces must not be omitted

Author: sharwell

AsyncUsageAnalyzers/AsyncUsageAnalyzers/Naming/AvoidAsyncSuffixAnalyzer.cs

@@ -61,17 +61,25 @@ public void HandleMethodDeclaration(SymbolAnalysisContext context)
             {
                 IMethodSymbol symbol = (IMethodSymbol)context.Symbol;
                 if (symbol.IsAsync)
+                {
                     return;
+                }
 
                 if (!symbol.Name.EndsWith("Async", StringComparison.Ordinal))
+                {
                     return;
+                }
 
                 if (symbol.Locations.IsDefaultOrEmpty)
+                {
                     return;
+                }
 
                 Location location = symbol.Locations[0];
                 if (!location.IsInSource || location.SourceTree.IsGeneratedDocument(this.generatedHeaderCache, context.CancellationToken))
+                {
                     return;
+                }
 
                 if (!symbol.ReturnsVoid)
                 {

AsyncUsageAnalyzers/AsyncUsageAnalyzers/Naming/UseAsyncSuffixAnalyzer.cs

@@ -61,27 +61,41 @@ public void HandleMethodDeclaration(SymbolAnalysisContext context)
             {
                 IMethodSymbol symbol = (IMethodSymbol)context.Symbol;
                 if (symbol.Name.EndsWith("Async", StringComparison.Ordinal))
+                {
                     return;
+                }
 
                 if (symbol.Locations.IsDefaultOrEmpty)
+                {
                     return;
+                }
 
                 Location location = symbol.Locations[0];
                 if (!location.IsInSource || location.SourceTree.IsGeneratedDocument(this.generatedHeaderCache, context.CancellationToken))
+                {
                     return;
+                }
 
                 // void-returning methods are not asynchronous according to their signature, even if they use `async`
                 if (symbol.ReturnsVoid)
+                {
                     return;
+                }
 
                 if (!string.Equals(nameof(Task), symbol.ReturnType?.Name, StringComparison.Ordinal))
+                {
                     return;
+                }
 
                 if (!string.Equals(typeof(Task).Namespace, symbol.ReturnType?.ContainingNamespace?.ToString(), StringComparison.Ordinal))
+                {
                     return;
+                }
 
                 if (symbol.MethodKind == MethodKind.PropertyGet || symbol.MethodKind == MethodKind.PropertySet)
+                {
                     return;
+                }
 
                 context.ReportDiagnostic(Diagnostic.Create(Descriptor, symbol.Locations[0], symbol.Name));
             }

AsyncUsageAnalyzers/AsyncUsageAnalyzers/Reliability/AvoidAsyncVoidAnalyzer.cs

@@ -62,18 +62,26 @@ private static void HandleAnonymousFunctionExpression(SyntaxNodeAnalysisContext
         {
             AnonymousFunctionExpressionSyntax node = (AnonymousFunctionExpressionSyntax)context.Node;
             if (node.AsyncKeyword.IsKind(SyntaxKind.None) || node.AsyncKeyword.IsMissing)
+            {
                 return;
+            }
 
             TypeInfo typeInfo = context.SemanticModel.GetTypeInfo(node);
             INamedTypeSymbol convertedType = typeInfo.ConvertedType as INamedTypeSymbol;
             if (convertedType == null)
+            {
                 return;
+            }
 
             if (convertedType.TypeKind != TypeKind.Delegate || convertedType.DelegateInvokeMethod == null)
+            {
                 return;
+            }
 
             if (!convertedType.DelegateInvokeMethod.ReturnsVoid)
+            {
                 return;
+            }
 
             context.ReportDiagnostic(Diagnostic.Create(Descriptor, node.AsyncKeyword.GetLocation(), "<anonymous>"));
         }
@@ -91,11 +99,15 @@ public void HandleMethodDeclaration(SymbolAnalysisContext context)
             {
                 IMethodSymbol symbol = (IMethodSymbol)context.Symbol;
                 if (!symbol.IsAsync || !symbol.ReturnsVoid)
+                {
                     return;
+                }
 
                 Location location = symbol.Locations[0];
                 if (!location.IsInSource || location.SourceTree.IsGeneratedDocument(this.generatedHeaderCache, context.CancellationToken))
+                {
                     return;
+                }
 
                 context.ReportDiagnostic(Diagnostic.Create(Descriptor, location, symbol.Name));
             }

AsyncUsageAnalyzers/AsyncUsageAnalyzers/Usage/UseConfigureAwaitAnalyzer.cs

@@ -55,7 +55,9 @@ private static void HandleAwaitExpression(SyntaxNodeAnalysisContext context)
             AwaitExpressionSyntax syntax = (AwaitExpressionSyntax)context.Node;
             ExpressionSyntax expression = syntax.Expression;
             if (!IsTask(expression, context.SemanticModel))
+            {
                 return;
+            }
 
             context.ReportDiagnostic(Diagnostic.Create(Descriptor, expression.GetLocation()));
         }
@@ -64,7 +66,9 @@ private static bool IsTask(ExpressionSyntax expression, SemanticModel semanticMo
         {
             var type = semanticModel.GetTypeInfo(expression).Type as INamedTypeSymbol;
             if (type == null)
+            {
                 return false;
+            }
 
             INamedTypeSymbol taskType;
             if (type.IsGenericType)