diff --git a/.github/workflows/build-and-test.yml b/.github/workflows/build-and-test.yml index e43f8398..964b4296 100644 --- a/.github/workflows/build-and-test.yml +++ b/.github/workflows/build-and-test.yml @@ -27,7 +27,7 @@ jobs: - run: dotnet test TestsOnly.slnf -c Release --no-build --logger "trx;LogFileName=test_results.trx" -p:CollectCoverage=true -p:Threshold=80 -p:CoverletOutputFormat='cobertura' - - uses: danielpalme/ReportGenerator-GitHub-Action@5 + - uses: danielpalme/ReportGenerator-GitHub-Action@5.3.8 with: reports: '/home/runner/work/ecoCode-csharp/ecoCode-csharp/src/EcoCode.Tests/coverage.cobertura.xml' targetdir: 'CoverageReports' diff --git a/Directory.Packages.props b/Directory.Packages.props index 5867e6d3..696a1ea2 100644 --- a/Directory.Packages.props +++ b/Directory.Packages.props @@ -21,8 +21,8 @@ - - + + diff --git a/NuGet.Config b/NuGet.Config deleted file mode 100644 index 1f4549ca..00000000 --- a/NuGet.Config +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - diff --git a/ecoCode-csharp.sln b/ecoCode-csharp.sln index c4521235..16826ae5 100644 --- a/ecoCode-csharp.sln +++ b/ecoCode-csharp.sln @@ -36,7 +36,6 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Directory.Packages.props = Directory.Packages.props EcoCode.globalconfig = EcoCode.globalconfig global.json = global.json - NuGet.Config = NuGet.Config Rules to work on.md = Rules to work on.md SharedAssemblyInfo.cs = SharedAssemblyInfo.cs EndProjectSection @@ -84,6 +83,9 @@ Global {375CBD0D-5754-352F-9D9D-ED72E2F1B0ED} = {089100B1-113F-4E66-888A-E83F3999EAFD} EndGlobalSection EndGlobal + + EndGlobalSection +EndGlobal } EndGlobalSection EndGlobal diff --git a/src/EcoCode.Core/Analyzers/EC69.DontCallFunctionsInLoopConditions.cs b/src/EcoCode.Core/Analyzers/EC69.DontCallFunctionsInLoopConditions.cs index 09bc8497..96cdf2df 100644 --- a/src/EcoCode.Core/Analyzers/EC69.DontCallFunctionsInLoopConditions.cs +++ b/src/EcoCode.Core/Analyzers/EC69.DontCallFunctionsInLoopConditions.cs @@ -47,40 +47,53 @@ private static void AnalyzeLoopNode(SyntaxNodeAnalysisContext context) { if (node is not InvocationExpressionSyntax invocation) continue; + // Analyze the object on which the method is called, if any + var callee = invocation.Expression switch + { + MemberAccessExpressionSyntax m => m.Expression, + MemberBindingExpressionSyntax => (node.Parent as ConditionalAccessExpressionSyntax)?.Expression, // ?. operator + _ => null, + }; + if (callee is not null && context.SemanticModel.GetSymbolInfo(callee).Symbol is ISymbol c && c.IsVariable()) + _ = loopInvariantSymbols.Add(c); + + // Analyze the arguments of the method call foreach (var arg in invocation.ArgumentList.Arguments) { - if (context.SemanticModel.GetSymbolInfo(arg.Expression).Symbol is ISymbol symbol && symbol.IsVariable()) - _ = loopInvariantSymbols.Add(symbol); + if (context.SemanticModel.GetSymbolInfo(arg.Expression).Symbol is ISymbol s && s.IsVariable()) + _ = loopInvariantSymbols.Add(s); } } - if (loopInvariantSymbols.Count == 0) return; - - // Step 2: Remove the variables that are mutated in the loop body or the for loop incrementors - RemoveMutatedSymbols(expression.DescendantNodes(), loopInvariantSymbols, context.SemanticModel); - if (loopInvariantSymbols.Count == 0) return; - foreach (var inc in incrementors) - RemoveMutatedSymbols(inc.DescendantNodesAndSelf(), loopInvariantSymbols, context.SemanticModel); - if (loopInvariantSymbols.Count == 0) return; + // Step 2: Remove the variables that are mutated in the loop body and/or the for loop incrementors + if (loopInvariantSymbols.Count != 0) + { + RemoveMutatedSymbols(expression.DescendantNodes(), loopInvariantSymbols, context.SemanticModel); + foreach (var inc in incrementors) + RemoveMutatedSymbols(inc.DescendantNodesAndSelf(), loopInvariantSymbols, context.SemanticModel); + } // Step 3: Identify conditions that are loop invariant foreach (var node in condition.DescendantNodes()) { if (node is not InvocationExpressionSyntax invocation) continue; - bool loopInvariant = true; - - foreach (var arg in invocation.ArgumentList.Arguments) + if (invocation.Expression is MemberBindingExpressionSyntax memberBinding) { - if (context.SemanticModel.GetSymbolInfo(arg.Expression).Symbol is ISymbol symbol && !loopInvariantSymbols.Contains(symbol)) + if (node.Parent is ConditionalAccessExpressionSyntax conditionalAccess && + IsLoopInvariant(conditionalAccess.Expression) && + invocation.ArgumentList.Arguments.All(arg => IsLoopInvariant(arg.Expression))) { - loopInvariant = false; - break; + context.ReportDiagnostic(Diagnostic.Create(Descriptor, conditionalAccess.GetLocation())); } + continue; } - if (loopInvariant) + if ((invocation.Expression is not MemberAccessExpressionSyntax memberAccess || IsLoopInvariant(memberAccess.Expression)) && + invocation.ArgumentList.Arguments.All(arg => IsLoopInvariant(arg.Expression))) + { context.ReportDiagnostic(Diagnostic.Create(Descriptor, invocation.GetLocation())); + } } static void RemoveMutatedSymbols(IEnumerable nodes, HashSet loopInvariantSymbols, SemanticModel semanticModel) @@ -100,5 +113,10 @@ static void RemoveMutatedSymbols(IEnumerable nodes, HashSet return; } } + + bool IsLoopInvariant(ExpressionSyntax expr) => + context.SemanticModel.GetSymbolInfo(expr).Symbol is not ISymbol s || + !s.IsVariable() || + loopInvariantSymbols.Contains(s); } } diff --git a/src/EcoCode.Core/Extensions/SymbolExtensions.cs b/src/EcoCode.Core/Extensions/SymbolExtensions.cs index eb6db0d2..288dfd48 100644 --- a/src/EcoCode.Core/Extensions/SymbolExtensions.cs +++ b/src/EcoCode.Core/Extensions/SymbolExtensions.cs @@ -1,4 +1,6 @@ -namespace EcoCode.Extensions; +using Microsoft.CodeAnalysis; + +namespace EcoCode.Extensions; /// Extensions methods for . public static class SymbolExtensions @@ -6,8 +8,12 @@ public static class SymbolExtensions /// Returns whether the symbol is a variable. /// The symbol. /// True if the symbol is a variable, false otherwise. - public static bool IsVariable(this ISymbol symbol) => - symbol is ILocalSymbol or IFieldSymbol or IPropertySymbol or IParameterSymbol; + public static bool IsVariable(this ISymbol symbol) => symbol switch + { + IFieldSymbol fieldSymbol => !fieldSymbol.HasConstantValue, + ILocalSymbol localSymbol => !localSymbol.HasConstantValue, + _ => symbol is IPropertySymbol or IParameterSymbol, + }; /// Returns whether the symbol is a variable of the specified type. /// The symbol. @@ -15,12 +21,12 @@ public static bool IsVariable(this ISymbol symbol) => /// True if the symbol is a variable of the given type, false otherwise. public static bool IsVariableOfType(this ISymbol symbol, SpecialType type) => symbol switch { - ILocalSymbol s => s.Type.SpecialType, - IFieldSymbol s => s.Type.SpecialType, - IPropertySymbol s => s.Type.SpecialType, - IParameterSymbol s => s.Type.SpecialType, - _ => SpecialType.None, - } == type; + IFieldSymbol s => !s.HasConstantValue && s.Type.SpecialType == type, + ILocalSymbol s => !s.HasConstantValue && s.Type.SpecialType == type, + IPropertySymbol s => s.Type.SpecialType == type, + IParameterSymbol s => s.Type.SpecialType == type, + _ => false, + }; /// Returns whether the symbol implements a given interface. /// The symbol. diff --git a/src/EcoCode.Tests/Tests/EC69.DontCallFunctionsInLoopConditions.Tests.cs b/src/EcoCode.Tests/Tests/EC69.DontCallFunctionsInLoopConditions.Tests.cs index 2a90fbb4..74fff9bc 100644 --- a/src/EcoCode.Tests/Tests/EC69.DontCallFunctionsInLoopConditions.Tests.cs +++ b/src/EcoCode.Tests/Tests/EC69.DontCallFunctionsInLoopConditions.Tests.cs @@ -6,10 +6,10 @@ public sealed class DontCallFunctionsInLoopConditionsTests private static readonly AnalyzerDlg VerifyAsync = TestRunner.VerifyAsync; [TestMethod] - public async Task EmptyCodeAsync() => await VerifyAsync("").ConfigureAwait(false); + public Task EmptyCodeAsync() => VerifyAsync(""); [TestMethod] - public async Task ForLoopFunctionCallShouldNotBeCalledAsync() => await VerifyAsync(""" + public Task ForLoopFunctionCallShouldNotBeCalledAsync() => VerifyAsync(""" public class Test { private const int C = 10; @@ -30,10 +30,10 @@ public void Run(int p) } } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task WhileLoopFunctionCallShouldNotBeCalledAsync() => await VerifyAsync(""" + public Task WhileLoopFunctionCallShouldNotBeCalledAsync() => VerifyAsync(""" public class Test { private const int C = 10; @@ -54,10 +54,10 @@ public void Run(int p) } } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task DoWhileLoopFunctionCallShouldNotBeCalledAsync() => await VerifyAsync(""" + public Task DoWhileLoopFunctionCallShouldNotBeCalledAsync() => VerifyAsync(""" public class Test { private const int C = 10; @@ -78,5 +78,45 @@ public void Run(int p) } while (i < V1 && i < [|V2()|] && i < V3(i) && i < V3(j) && i < [|V3(k)|] && i < [|V3(p)|] && i < [|V3(C)|]); } } - """).ConfigureAwait(false); + """); + + [TestMethod] + public Task WithLoopVariantNullablesAsync() => VerifyAsync(""" + using System; + using System.IO; + public class Test + { + public static void Run1(string? path) + { + for (path = Path.GetDirectoryName(path); !path.Equals(@"S:\", StringComparison.OrdinalIgnoreCase); path = Path.GetDirectoryName(path)) { } + for (path = Path.GetDirectoryName(path); path?.Equals(@"S:\", StringComparison.OrdinalIgnoreCase) != true; path = Path.GetDirectoryName(path)) { } + + while (!path.Equals(@"S:\", StringComparison.OrdinalIgnoreCase)) path = Path.GetDirectoryName(path); + while (path?.Equals(@"S:\", StringComparison.OrdinalIgnoreCase) != true) path = Path.GetDirectoryName(path); + + do path = Path.GetDirectoryName(path); while (!path.Equals(@"S:\", StringComparison.OrdinalIgnoreCase)); + do path = Path.GetDirectoryName(path); while (path?.Equals(@"S:\", StringComparison.OrdinalIgnoreCase) != true); + } + } + """); + + [TestMethod] + public Task WithLoopInvariantNullablesAsync() => VerifyAsync(""" + using System; + using System.IO; + public class Test + { + public static void Run(string? path) + { + for (path = Path.GetDirectoryName(path); ![|path.Equals(@"S:\", StringComparison.OrdinalIgnoreCase)|]; ) { } + for (path = Path.GetDirectoryName(path); [|path?.Equals(@"S:\", StringComparison.OrdinalIgnoreCase)|] != true; ) { } + + while (![|path.Equals(@"S:\", StringComparison.OrdinalIgnoreCase)|]) ; + while ([|path?.Equals(@"S:\", StringComparison.OrdinalIgnoreCase)|] != true) ; + + do ; while (![|path.Equals(@"S:\", StringComparison.OrdinalIgnoreCase)|]); + do ; while ([|path?.Equals(@"S:\", StringComparison.OrdinalIgnoreCase)|] != true); + } + } + """); } diff --git a/src/EcoCode.Tests/Tests/EC72.DontExecuteSqlCommandsInLoops.Tests.cs b/src/EcoCode.Tests/Tests/EC72.DontExecuteSqlCommandsInLoops.Tests.cs index aee13113..b994e2c5 100644 --- a/src/EcoCode.Tests/Tests/EC72.DontExecuteSqlCommandsInLoops.Tests.cs +++ b/src/EcoCode.Tests/Tests/EC72.DontExecuteSqlCommandsInLoops.Tests.cs @@ -6,10 +6,10 @@ public sealed class DontExecuteSqlCommandsInLoopsTests private static readonly AnalyzerDlg VerifyAsync = TestRunner.VerifyAsync; [TestMethod] - public async Task EmptyCodeAsync() => await VerifyAsync("").ConfigureAwait(false); + public Task EmptyCodeAsync() => VerifyAsync(""); [TestMethod] - public async Task DontExecuteSqlCommandsInLoopsAsync() => await VerifyAsync(""" + public Task DontExecuteSqlCommandsInLoopsAsync() => VerifyAsync(""" using System.Data; public class Test { @@ -30,5 +30,5 @@ public void Run(int p) } } } - """).ConfigureAwait(false); + """); } diff --git a/src/EcoCode.Tests/Tests/EC75.DontConcatenateStringsInLoops.Tests.cs b/src/EcoCode.Tests/Tests/EC75.DontConcatenateStringsInLoops.Tests.cs index 9b27b403..5672a29a 100644 --- a/src/EcoCode.Tests/Tests/EC75.DontConcatenateStringsInLoops.Tests.cs +++ b/src/EcoCode.Tests/Tests/EC75.DontConcatenateStringsInLoops.Tests.cs @@ -6,7 +6,7 @@ public sealed class DontConcatenateStringsInLoopsTests private static readonly AnalyzerDlg VerifyAsync = TestRunner.VerifyAsync; [TestMethod] - public async Task EmptyCodeAsync() => await VerifyAsync("").ConfigureAwait(false); + public Task EmptyCodeAsync() => VerifyAsync(""); private const string WarningCode = """ @@ -22,7 +22,7 @@ public sealed class DontConcatenateStringsInLoopsTests #region Regular loops [TestMethod] - public async Task DontConcatenateStringsInLoopsParameterWithAllLoopsAsync() => await VerifyAsync($$""" + public Task DontConcatenateStringsInLoopsParameterWithAllLoopsAsync() => VerifyAsync($$""" using System.Linq; class Test { @@ -48,10 +48,10 @@ void Run4(string s) do{{WarningCode}} while (++i < 10); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task DontConcatenateStringsInLoopsFieldAsync() => await VerifyAsync($$""" + public Task DontConcatenateStringsInLoopsFieldAsync() => VerifyAsync($$""" class Test { string s = string.Empty; @@ -60,10 +60,10 @@ void Run() for (int i = 0; i < 10; i++){{WarningCode}} } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task DontConcatenateStringsInLoopsPropertyAsync() => await VerifyAsync($$""" + public Task DontConcatenateStringsInLoopsPropertyAsync() => VerifyAsync($$""" class Test { string s { get; set; } = string.Empty; @@ -72,10 +72,10 @@ void Run() for (int i = 0; i < 10; i++){{WarningCode}} } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task DontConcatenateStringsInLoopsStaticFieldAsync() => await VerifyAsync($$""" + public Task DontConcatenateStringsInLoopsStaticFieldAsync() => VerifyAsync($$""" class Test { static string s = string.Empty; @@ -84,10 +84,10 @@ void Run() for (int i = 0; i < 10; i++){{WarningCode}} } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task DontConcatenateStringsInLoopsStaticPropertyAsync() => await VerifyAsync($$""" + public Task DontConcatenateStringsInLoopsStaticPropertyAsync() => VerifyAsync($$""" class Test { static string s { get; set; } = string.Empty; @@ -96,10 +96,10 @@ void Run() for (int i = 0; i < 10; i++){{WarningCode}} } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task DontConcatenateStringsInLoopsLocalVariableAsync() => await VerifyAsync($$""" + public Task DontConcatenateStringsInLoopsLocalVariableAsync() => VerifyAsync($$""" class Test { void Run() @@ -118,7 +118,7 @@ void Run() } } } - """).ConfigureAwait(false); + """); #endregion @@ -127,7 +127,7 @@ void Run() [TestMethod] [DataRow("List")] [DataRow("ImmutableList")] - public async Task DontConcatenateStringsInForEachParameterAsync(string type) => await VerifyAsync($$""" + public Task DontConcatenateStringsInForEachParameterAsync(string type) => VerifyAsync($$""" using System.Collections.Generic; using System.Collections.Immutable; using System.Threading.Tasks; @@ -148,12 +148,12 @@ public void Run({{type}} list, string s) Parallel.ForEach(list, i => s = i.ToString() + i.ToString()); } } - """).ConfigureAwait(false); + """); [TestMethod] [DataRow("List")] [DataRow("ImmutableList")] - public async Task DontConcatenateStringsInForEachFieldAsync(string type) => await VerifyAsync($$""" + public Task DontConcatenateStringsInForEachFieldAsync(string type) => VerifyAsync($$""" using System.Collections.Generic; using System.Collections.Immutable; using System.Threading.Tasks; @@ -175,12 +175,12 @@ public void Run({{type}} list) Parallel.ForEach(list, i => s = i.ToString() + i.ToString()); } } - """).ConfigureAwait(false); + """); [TestMethod] [DataRow("List")] [DataRow("ImmutableList")] - public async Task DontConcatenateStringsInForEachPropertyAsync(string type) => await VerifyAsync($$""" + public Task DontConcatenateStringsInForEachPropertyAsync(string type) => VerifyAsync($$""" using System.Collections.Generic; using System.Collections.Immutable; using System.Threading.Tasks; @@ -202,12 +202,12 @@ public void Run({{type}} list) Parallel.ForEach(list, i => s = i.ToString() + i.ToString()); } } - """).ConfigureAwait(false); + """); [TestMethod] [DataRow("List")] [DataRow("ImmutableList")] - public async Task DontConcatenateStringsInForEachStaticFieldAsync(string type) => await VerifyAsync($$""" + public Task DontConcatenateStringsInForEachStaticFieldAsync(string type) => VerifyAsync($$""" using System.Collections.Generic; using System.Collections.Immutable; using System.Threading.Tasks; @@ -229,12 +229,12 @@ public void Run({{type}} list) Parallel.ForEach(list, i => s = i.ToString() + i.ToString()); } } - """).ConfigureAwait(false); + """); [TestMethod] [DataRow("List")] [DataRow("ImmutableList")] - public async Task DontConcatenateStringsInForEachStaticPropertyAsync(string type) => await VerifyAsync($$""" + public Task DontConcatenateStringsInForEachStaticPropertyAsync(string type) => VerifyAsync($$""" using System.Collections.Generic; using System.Collections.Immutable; using System.Threading.Tasks; @@ -256,12 +256,12 @@ public void Run({{type}} list) Parallel.ForEach(list, i => s = i.ToString() + i.ToString()); } } - """).ConfigureAwait(false); + """); [TestMethod] [DataRow("List")] [DataRow("ImmutableList")] - public async Task DontConcatenateStringsInForEachLocalVariableAsync(string type) => await VerifyAsync($$""" + public Task DontConcatenateStringsInForEachLocalVariableAsync(string type) => VerifyAsync($$""" using System.Collections.Generic; using System.Collections.Immutable; using System.Threading.Tasks; @@ -303,7 +303,7 @@ public void Run({{type}} list) }); } } - """).ConfigureAwait(false); + """); #endregion } diff --git a/src/EcoCode.Tests/Tests/EC81.SpecifyStructLayout.Tests.cs b/src/EcoCode.Tests/Tests/EC81.SpecifyStructLayout.Tests.cs index 375cb59b..7b456c89 100644 --- a/src/EcoCode.Tests/Tests/EC81.SpecifyStructLayout.Tests.cs +++ b/src/EcoCode.Tests/Tests/EC81.SpecifyStructLayout.Tests.cs @@ -6,23 +6,23 @@ public sealed class SpecifyStructLayoutTests private static readonly CodeFixerDlg VerifyAsync = TestRunner.VerifyAsync; [TestMethod] - public async Task EmptyCodeAsync() => await VerifyAsync("").ConfigureAwait(false); + public Task EmptyCodeAsync() => VerifyAsync(""); [TestMethod] - public async Task EmptyStructWithNoLayoutAsync() => await VerifyAsync( - "public record struct TestStruct;").ConfigureAwait(false); + public Task EmptyStructWithNoLayoutAsync() => VerifyAsync( + "public record struct TestStruct;"); [TestMethod] - public async Task ValuePropWithNoLayoutAsync() => await VerifyAsync( - "public record struct TestStruct(int A);").ConfigureAwait(false); + public Task ValuePropWithNoLayoutAsync() => VerifyAsync( + "public record struct TestStruct(int A);"); [TestMethod] - public async Task ReferencePropWithNoLayoutAsync() => await VerifyAsync( - "public record struct TestStruct(string A);").ConfigureAwait(false); + public Task ReferencePropWithNoLayoutAsync() => VerifyAsync( + "public record struct TestStruct(string A);"); [TestMethod] // For some reason this test doesn't pass with the 'record' syntax on GitHub, but it passes locally.. - public async Task ValuePropsWithNoLayoutAsync() => await VerifyAsync(""" + public Task ValuePropsWithNoLayoutAsync() => VerifyAsync(""" public struct [|TestStruct|] { public int A { get; set; } @@ -37,23 +37,23 @@ public struct TestStruct public int A { get; set; } public double B { get; set; } }; - """).ConfigureAwait(false); + """); [TestMethod] - public async Task ValuePropsWithLayoutAsync() => await VerifyAsync(""" + public Task ValuePropsWithLayoutAsync() => VerifyAsync(""" using System.Runtime.InteropServices; [StructLayout(LayoutKind.Auto)] public record struct TestStruct(int A, double B); - """).ConfigureAwait(false); + """); [TestMethod] - public async Task ValueAndReferencePropsWithNoLayoutAsync() => await VerifyAsync( - "public record struct TestStruct(int A, string B);").ConfigureAwait(false); + public Task ValueAndReferencePropsWithNoLayoutAsync() => VerifyAsync( + "public record struct TestStruct(int A, string B);"); [TestMethod] // For some reason this test doesn't pass with the 'record' syntax on GitHub, but it passes locally.. - public async Task AdditionalValuePropsWithNoLayout1Async() => await VerifyAsync(""" + public Task AdditionalValuePropsWithNoLayout1Async() => VerifyAsync(""" public struct [|TestStruct|] { public int A { get; set; } @@ -70,10 +70,10 @@ public struct TestStruct public double B { get; set; } public int C { get; set; } }; - """).ConfigureAwait(false); + """); [TestMethod] - public async Task AdditionalValueFieldsWithNoLayout2Async() => await VerifyAsync(""" + public Task AdditionalValueFieldsWithNoLayout2Async() => VerifyAsync(""" using System; public record struct [|TestStruct|](bool A, int B, char C, short D, ulong E, DateTime F); @@ -83,5 +83,5 @@ public record struct [|TestStruct|](bool A, int B, char C, short D, ulong E, Dat [StructLayout(LayoutKind.Auto)] public record struct [|TestStruct|](bool A, int B, char C, short D, ulong E, DateTime F); - """).ConfigureAwait(false); + """); } diff --git a/src/EcoCode.Tests/Tests/EC82.VariableCanBeMadeConstant.Tests.cs b/src/EcoCode.Tests/Tests/EC82.VariableCanBeMadeConstant.Tests.cs index d0cbed78..0d6c1212 100644 --- a/src/EcoCode.Tests/Tests/EC82.VariableCanBeMadeConstant.Tests.cs +++ b/src/EcoCode.Tests/Tests/EC82.VariableCanBeMadeConstant.Tests.cs @@ -6,10 +6,10 @@ public sealed class VariableCanBeMadeConstantTests private static readonly CodeFixerDlg VerifyAsync = TestRunner.VerifyAsync; [TestMethod] - public async Task EmptyCodeAsync() => await VerifyAsync("").ConfigureAwait(false); + public Task EmptyCodeAsync() => VerifyAsync(""); [TestMethod] - public async Task VariableCanBeConstAsync() => await VerifyAsync(""" + public Task VariableCanBeConstAsync() => VerifyAsync(""" using System; public class Program { @@ -29,10 +29,10 @@ public static void Main() Console.WriteLine(i); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task VariableIsReassignedAsync() => await VerifyAsync(""" + public Task VariableIsReassignedAsync() => VerifyAsync(""" using System; public class Program { @@ -42,10 +42,10 @@ public static void Main() Console.WriteLine(i++); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task VariableIsAlreadyConstAsync() => await VerifyAsync(""" + public Task VariableIsAlreadyConstAsync() => VerifyAsync(""" using System; public class Program { @@ -55,10 +55,10 @@ public static void Main() Console.WriteLine(i); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task VariableHasNoInitializerAsync() => await VerifyAsync(""" + public Task VariableHasNoInitializerAsync() => VerifyAsync(""" using System; public class Program { @@ -69,10 +69,10 @@ public static void Main() Console.WriteLine(i); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task VariableCannotBeConstAsync() => await VerifyAsync(""" + public Task VariableCannotBeConstAsync() => VerifyAsync(""" using System; public class Program { @@ -82,10 +82,10 @@ public static void Main() Console.WriteLine(i); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task VariableWithMultipleInitializersCannotBeConstAsync() => await VerifyAsync(""" + public Task VariableWithMultipleInitializersCannotBeConstAsync() => VerifyAsync(""" using System; public class Program { @@ -96,10 +96,10 @@ public static void Main() Console.WriteLine(j); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task VariableWithMultipleInitializersCanBeConstAsync() => await VerifyAsync(""" + public Task VariableWithMultipleInitializersCanBeConstAsync() => VerifyAsync(""" using System; public class Program { @@ -121,10 +121,10 @@ public static void Main() Console.WriteLine(j); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task VariableInitializerIsInvalidAsync() => await VerifyAsync(""" + public Task VariableInitializerIsInvalidAsync() => VerifyAsync(""" using System; public class Program { @@ -133,10 +133,10 @@ public static void Main() int x = {|CS0029:"abc"|}; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task StringObjectCannotBeConstAsync() => await VerifyAsync(""" + public Task StringObjectCannotBeConstAsync() => VerifyAsync(""" using System; public class Program { @@ -145,10 +145,10 @@ public static void Main() object s = "abc"; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task StringCanBeConstAsync() => await VerifyAsync(""" + public Task StringCanBeConstAsync() => VerifyAsync(""" using System; public class Program { @@ -166,10 +166,10 @@ public static void Main() const string s = "abc"; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task VarIntCanBeConstAsync() => await VerifyAsync(""" + public Task VarIntCanBeConstAsync() => VerifyAsync(""" using System; public class Program { @@ -187,10 +187,10 @@ public static void Main() const int item = 4; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task VarStringCanBeConstAsync() => await VerifyAsync(""" + public Task VarStringCanBeConstAsync() => VerifyAsync(""" using System; public class Program { @@ -208,5 +208,5 @@ public static void Main() const string item = "abc"; } } - """).ConfigureAwait(false); + """); } diff --git a/src/EcoCode.Tests/Tests/EC83.ReplaceEnumToStringWithNameOf.Tests.cs b/src/EcoCode.Tests/Tests/EC83.ReplaceEnumToStringWithNameOf.Tests.cs index 6831655e..8d44baa9 100644 --- a/src/EcoCode.Tests/Tests/EC83.ReplaceEnumToStringWithNameOf.Tests.cs +++ b/src/EcoCode.Tests/Tests/EC83.ReplaceEnumToStringWithNameOf.Tests.cs @@ -6,10 +6,10 @@ public sealed class ReplaceEnumToStringWithNameOfTests private static readonly CodeFixerDlg VerifyAsync = TestRunner.VerifyAsync; [TestMethod] - public async Task EmptyCodeAsync() => await VerifyAsync("").ConfigureAwait(false); + public Task EmptyCodeAsync() => VerifyAsync(""); [TestMethod] - public async Task EnumToStringShouldBeNameOfAsync1() => await VerifyAsync(""" + public Task EnumToStringShouldBeNameOfAsync1() => VerifyAsync(""" using System; public static class Program { @@ -35,10 +35,10 @@ public static void Main() Console.WriteLine(nameof(MyEnum.D)); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task EnumToStringShouldBeNameOfAsync2() => await VerifyAsync(""" + public Task EnumToStringShouldBeNameOfAsync2() => VerifyAsync(""" using System; public static class Program { @@ -62,10 +62,10 @@ public static void Main() Console.WriteLine(MyEnum.C.ToString("N")); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task EnumInterpolationShouldBeNameOfAsync() => await VerifyAsync(""" + public Task EnumInterpolationShouldBeNameOfAsync() => VerifyAsync(""" using System; public static class Program { @@ -91,5 +91,5 @@ public static void Main() Console.WriteLine($"{MyEnum.D:N}"); } } - """).ConfigureAwait(false); + """); } diff --git a/src/EcoCode.Tests/Tests/EC84.AvoidAsyncVoidMethods.Tests.cs b/src/EcoCode.Tests/Tests/EC84.AvoidAsyncVoidMethods.Tests.cs index 31c81bed..8f921ab5 100644 --- a/src/EcoCode.Tests/Tests/EC84.AvoidAsyncVoidMethods.Tests.cs +++ b/src/EcoCode.Tests/Tests/EC84.AvoidAsyncVoidMethods.Tests.cs @@ -6,17 +6,17 @@ public sealed class AvoidAsyncVoidMethodsTests private static readonly CodeFixerDlg VerifyAsync = TestRunner.VerifyAsync; [TestMethod] - public async Task EmptyCodeAsync() => await VerifyAsync("").ConfigureAwait(false); + public Task EmptyCodeAsync() => VerifyAsync(""); [TestMethod] - public async Task AvoidAsyncVoidMethodAsync() => await VerifyAsync(""" + public Task AvoidAsyncVoidMethodAsync() => VerifyAsync(""" using System; using System.Threading.Tasks; public static class Program { public static async void [|Main|]() { - await Task.Delay(1000).ConfigureAwait(false); + await Task.Delay(1000); Console.WriteLine(); } } @@ -27,14 +27,14 @@ public static class Program { public static async Task Main() { - await Task.Delay(1000).ConfigureAwait(false); + await Task.Delay(1000); Console.WriteLine(); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task AvoidAsyncVoidMethodWithMissingUsingAsync() => await VerifyAsync(""" + public Task AvoidAsyncVoidMethodWithMissingUsingAsync() => VerifyAsync(""" using System; using System.Net.Http; public static class Program @@ -42,7 +42,7 @@ public static class Program public static async void [|Main|]() { using var httpClient = new HttpClient(); - _ = await httpClient.GetAsync(new Uri("URL")).ConfigureAwait(false); + _ = await httpClient.GetAsync(new Uri("URL")); } } """, """ @@ -53,35 +53,35 @@ public static class Program public static async {|CS0246:Task|} {|CS0161:Main|}() { using var httpClient = new HttpClient(); - _ = await httpClient.GetAsync(new Uri("URL")).ConfigureAwait(false); + _ = await httpClient.GetAsync(new Uri("URL")); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task AsyncTaskMethodIsOkAsync() => await VerifyAsync(""" + public Task AsyncTaskMethodIsOkAsync() => VerifyAsync(""" using System; using System.Threading.Tasks; public static class Program { public static async Task Main() { - await Task.Delay(1000).ConfigureAwait(false); + await Task.Delay(1000); Console.WriteLine(); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task AsyncGenericTaskMethodIsOkAsync() => await VerifyAsync(""" + public Task AsyncGenericTaskMethodIsOkAsync() => VerifyAsync(""" using System.Threading.Tasks; public static class Program { public static async Task Main() { - await Task.Delay(1000).ConfigureAwait(false); + await Task.Delay(1000); return 1; } } - """).ConfigureAwait(false); + """); } diff --git a/src/EcoCode.Tests/Tests/EC85.MakeTypeSealed.Tests.cs b/src/EcoCode.Tests/Tests/EC85.MakeTypeSealed.Tests.cs index 4ce9f23c..f89595b9 100644 --- a/src/EcoCode.Tests/Tests/EC85.MakeTypeSealed.Tests.cs +++ b/src/EcoCode.Tests/Tests/EC85.MakeTypeSealed.Tests.cs @@ -6,10 +6,10 @@ public sealed class MakeTypeSealedTests private static readonly AnalyzerDlg AnalyzeAsync = TestRunner.VerifyAsync; [TestMethod] - public async Task EmptyCodeAsync() => await AnalyzeAsync("").ConfigureAwait(false); + public Task EmptyCodeAsync() => AnalyzeAsync(""); [TestMethod] - public async Task SealableClassesAsync() => await AnalyzeAsync(""" + public Task SealableClassesAsync() => AnalyzeAsync(""" public class [|TestA|]; internal class [|TestB|]; public static class Test0 @@ -24,10 +24,10 @@ public class [|Test11|]; internal class [|Test12|]; private class [|Test13|]; } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task SealableRecordsAsync() => await AnalyzeAsync(""" + public Task SealableRecordsAsync() => AnalyzeAsync(""" public record [|TestA|]; internal record [|TestB|]; public static class Test0 @@ -42,10 +42,10 @@ public record [|Test11|]; internal record [|Test12|]; private record [|Test13|]; } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task NonSealableStructsAsync() => await AnalyzeAsync(""" + public Task NonSealableStructsAsync() => AnalyzeAsync(""" public struct TestA; internal struct TestB; public static class Test0 @@ -60,10 +60,10 @@ public struct Test11; internal struct Test12; private struct Test13; } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task StaticClassesAsync() => await AnalyzeAsync(""" + public Task StaticClassesAsync() => AnalyzeAsync(""" public static class Test0 { public static class Test01; @@ -76,10 +76,10 @@ public static class Test11; internal static class Test12; private static class Test13; } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task AbstractClassesAsync() => await AnalyzeAsync(""" + public Task AbstractClassesAsync() => AnalyzeAsync(""" public abstract class TestA; internal abstract class TestB; public static class Test0 @@ -94,10 +94,10 @@ public abstract class Test11; internal abstract class Test12; private abstract class Test13; } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task SealedClassesAsync() => await AnalyzeAsync(""" + public Task SealedClassesAsync() => AnalyzeAsync(""" public sealed class TestA; internal sealed class TestB; public static class Test0 @@ -112,10 +112,10 @@ public sealed class Test11; internal sealed class Test12; private sealed class Test13; } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task SealableClassesWithInterfaceAsync() => await AnalyzeAsync(""" + public Task SealableClassesWithInterfaceAsync() => AnalyzeAsync(""" public interface ITest { void Method(); } public class [|TestA|] : ITest { public void Method() { } } internal class [|TestB|] : ITest { public void Method() { } } @@ -131,10 +131,10 @@ public class [|Test11|] : ITest { public void Method() { } } internal class [|Test12|] : ITest { public void Method() { } } private class [|Test13|] : ITest { public void Method() { } } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task SealableClassesWithOverridableAsync() => await AnalyzeAsync(""" + public Task SealableClassesWithOverridableAsync() => AnalyzeAsync(""" public class TestA1 { public virtual void Method() { } }; public class [|TestA2|] { internal virtual void Method() { } }; public class TestA3 { protected virtual void Method() { } }; @@ -188,10 +188,10 @@ private class [|TestC3|] { protected virtual void Method() { } }; private class [|TestC4|] { protected internal virtual void Method() { } }; private class [|TestC5|] { private protected virtual void Method() { } }; } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task InheritanceAsync() => await AnalyzeAsync(""" + public Task InheritanceAsync() => AnalyzeAsync(""" public abstract class Test2 { public virtual void Overridable() { } } public class Test3 : Test2; public sealed class Test4 : Test3; @@ -200,10 +200,10 @@ public class Test6 : Test3 { public override void Overridable() { } } public class [|Test7|] : Test3 { public sealed override void Overridable() { } } public class Test8 : Test3 { public sealed override void Overridable() { } } public class [|Test9|] : Test8; - """).ConfigureAwait(false); + """); [TestMethod] - public async Task PartialAsync() => await AnalyzeAsync(""" + public Task PartialAsync() => AnalyzeAsync(""" public partial class [|Test1|]; partial class Test1 { public void Method() { } } @@ -215,10 +215,10 @@ partial class Test3 { public virtual void Method() { } } public partial class Test4; sealed partial class Test4 { public void Method() { } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task Partial2Async() => await AnalyzeAsync(""" + public Task Partial2Async() => AnalyzeAsync(""" public partial class [|Test1|]; partial class Test1(int Value) { public int Method() => Value; } @@ -235,5 +235,5 @@ partial class Test3 { public virtual void Method() { } } public partial class Test4; sealed partial class Test4(int Value) { public int Method() => Value; } - """).ConfigureAwait(false); + """); } diff --git a/src/EcoCode.Tests/Tests/EC86.GCCollectShouldNotBeCalled.Tests.cs b/src/EcoCode.Tests/Tests/EC86.GCCollectShouldNotBeCalled.Tests.cs index 07ad1c75..912e6b4b 100644 --- a/src/EcoCode.Tests/Tests/EC86.GCCollectShouldNotBeCalled.Tests.cs +++ b/src/EcoCode.Tests/Tests/EC86.GCCollectShouldNotBeCalled.Tests.cs @@ -6,10 +6,10 @@ public class GCCollectShouldNotBeCalledTests private static readonly AnalyzerDlg VerifyAsync = TestRunner.VerifyAsync; [TestMethod] - public async Task EmptyCodeAsync() => await VerifyAsync("").ConfigureAwait(false); + public Task EmptyCodeAsync() => VerifyAsync(""); [TestMethod] - public async Task GCCollectShouldNotBeCalledAsync() => await VerifyAsync(""" + public Task GCCollectShouldNotBeCalledAsync() => VerifyAsync(""" using System; public static class Program { @@ -18,10 +18,10 @@ public static async void Main() [|GC.Collect()|]; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task GCCollectShouldNotBeCalledSystemAsync() => await VerifyAsync(""" + public Task GCCollectShouldNotBeCalledSystemAsync() => VerifyAsync(""" using System; public static class Program { @@ -30,10 +30,10 @@ public static async void Main() [|System.GC.Collect()|]; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task GCCollectShouldNotBeCalledNamedArgumentsAsync() => await VerifyAsync(""" + public Task GCCollectShouldNotBeCalledNamedArgumentsAsync() => VerifyAsync(""" using System; public static class Program { @@ -42,10 +42,10 @@ public static async void Main() [|GC.Collect(mode: GCCollectionMode.Optimized, generation: 1)|]; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task GCCollectShouldNotBeCalledMultipleCodeAsync() => await VerifyAsync(""" + public Task GCCollectShouldNotBeCalledMultipleCodeAsync() => VerifyAsync(""" using System; public static class Program { @@ -54,10 +54,10 @@ public static async void Main() string text=""; [|GC.Collect()|]; string text2 = ""; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task GCCollectShouldNotBeCalledCommentedAsync() => await VerifyAsync(""" + public Task GCCollectShouldNotBeCalledCommentedAsync() => VerifyAsync(""" using System; public static class Program { @@ -66,10 +66,10 @@ public static async void Main() //GC.Collect(); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task GCCollectShouldNotBeCalledGeneration0Async() => await VerifyAsync(""" + public Task GCCollectShouldNotBeCalledGeneration0Async() => VerifyAsync(""" using System; public static class Program { @@ -78,10 +78,10 @@ public static async void Main() GC.Collect(0); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task GCCollectShouldNotBeCalledGeneration10Async() => await VerifyAsync(""" + public Task GCCollectShouldNotBeCalledGeneration10Async() => VerifyAsync(""" using System; public static class Program { @@ -90,10 +90,10 @@ public static async void Main() [|GC.Collect(10)|]; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task GCCollectShouldNotBeCalledGeneratio0CollectionModeAsync() => await VerifyAsync(""" + public Task GCCollectShouldNotBeCalledGeneratio0CollectionModeAsync() => VerifyAsync(""" using System; public static class Program { @@ -102,10 +102,10 @@ public static async void Main() GC.Collect(0, GCCollectionMode.Forced); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task GCCollectShouldNotBeCalledGeneration10CollectionModeAsync() => await VerifyAsync(""" + public Task GCCollectShouldNotBeCalledGeneration10CollectionModeAsync() => VerifyAsync(""" using System; public static class Program { @@ -114,5 +114,5 @@ public static async void Main() [|GC.Collect(10, GCCollectionMode.Forced)|]; } } - """).ConfigureAwait(false); + """); } diff --git a/src/EcoCode.Tests/Tests/EC87.UseListIndexer.Tests.cs b/src/EcoCode.Tests/Tests/EC87.UseListIndexer.Tests.cs index 0598a308..fa9c6e0c 100644 --- a/src/EcoCode.Tests/Tests/EC87.UseListIndexer.Tests.cs +++ b/src/EcoCode.Tests/Tests/EC87.UseListIndexer.Tests.cs @@ -6,7 +6,7 @@ public sealed class UseListIndexerTests private static readonly CodeFixerDlg VerifyAsync = TestRunner.VerifyAsync; [TestMethod] - public async Task EmptyCodeAsync() => await VerifyAsync("").ConfigureAwait(false); + public Task EmptyCodeAsync() => VerifyAsync(""); #region First diff --git a/src/EcoCode.Tests/Tests/EC88.DisposeResourceAsynchronously.Tests.cs b/src/EcoCode.Tests/Tests/EC88.DisposeResourceAsynchronously.Tests.cs index 13c168a4..fd798141 100644 --- a/src/EcoCode.Tests/Tests/EC88.DisposeResourceAsynchronously.Tests.cs +++ b/src/EcoCode.Tests/Tests/EC88.DisposeResourceAsynchronously.Tests.cs @@ -6,7 +6,7 @@ public sealed class DisposeResourceAsynchronouslyTests private static readonly CodeFixerDlg VerifyAsync = TestRunner.VerifyAsync; [TestMethod] - public async Task EmptyCodeAsync() => await VerifyAsync("").ConfigureAwait(false); + public Task EmptyCodeAsync() => VerifyAsync(""); [TestMethod] public Task DontWarnOnMissingUsingsAsync() => VerifyAsync(""" diff --git a/src/EcoCode.Tests/Tests/EC91.UseWhereBeforeOrderBy.Tests.cs b/src/EcoCode.Tests/Tests/EC91.UseWhereBeforeOrderBy.Tests.cs index 515d4996..56cc35fd 100644 --- a/src/EcoCode.Tests/Tests/EC91.UseWhereBeforeOrderBy.Tests.cs +++ b/src/EcoCode.Tests/Tests/EC91.UseWhereBeforeOrderBy.Tests.cs @@ -6,12 +6,12 @@ public sealed class UseWhereBeforeOrderByTests private static readonly CodeFixerDlg VerifyAsync = TestRunner.VerifyAsync; [TestMethod] - public async Task EmptyCodeAsync() => await VerifyAsync("").ConfigureAwait(false); + public Task EmptyCodeAsync() => VerifyAsync(""); #region Method syntax [TestMethod] - public async Task DontWarnOnWhereOnlyMethodAsync() => await VerifyAsync(""" + public Task DontWarnOnWhereOnlyMethodAsync() => VerifyAsync(""" using System.Linq; using System.Collections.Generic; @@ -25,10 +25,10 @@ public static void Run() .Select(x => x); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task DontWarnOnOrderByOnlyMethodAsync() => await VerifyAsync(""" + public Task DontWarnOnOrderByOnlyMethodAsync() => VerifyAsync(""" using System.Linq; using System.Collections.Generic; @@ -42,10 +42,10 @@ public static void Run() .Select(x => x); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task DontWarnOnOrderByDescendingOnlyMethodAsync() => await VerifyAsync(""" + public Task DontWarnOnOrderByDescendingOnlyMethodAsync() => VerifyAsync(""" using System.Linq; using System.Collections.Generic; @@ -59,10 +59,10 @@ public static void Run() .Select(x => x); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task DontWarnOnRightOrderMethodAsync() => await VerifyAsync(""" + public Task DontWarnOnRightOrderMethodAsync() => VerifyAsync(""" using System.Linq; using System.Collections.Generic; @@ -77,10 +77,10 @@ public static void Run() .Select(x => x); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task WarnOnWrongOrderMethodAsync() => await VerifyAsync(""" + public Task WarnOnWrongOrderMethodAsync() => VerifyAsync(""" using System.Linq; using System.Collections.Generic; @@ -112,10 +112,10 @@ public static void Run() .Select(x => x); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task WarnOnWrongOrderDescendingMethodAsync() => await VerifyAsync(""" + public Task WarnOnWrongOrderDescendingMethodAsync() => VerifyAsync(""" using System.Linq; using System.Collections.Generic; @@ -147,10 +147,10 @@ public static void Run() .Select(x => x); } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task WarnOnWrongMultipleOrderMethodAsync() => await VerifyAsync(""" + public Task WarnOnWrongMultipleOrderMethodAsync() => VerifyAsync(""" using System.Linq; using System.Collections.Generic; @@ -186,14 +186,14 @@ public static void Run() .Select(x => x); } } - """).ConfigureAwait(false); + """); #endregion #region Query syntax [TestMethod] - public async Task DontWarnOnWhereOnlyQueryAsync() => await VerifyAsync(""" + public Task DontWarnOnWhereOnlyQueryAsync() => VerifyAsync(""" using System.Linq; using System.Collections.Generic; @@ -207,10 +207,10 @@ where item > 10 select item; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task DontWarnOnOrderByOnlyQueryAsync() => await VerifyAsync(""" + public Task DontWarnOnOrderByOnlyQueryAsync() => VerifyAsync(""" using System.Linq; using System.Collections.Generic; @@ -224,10 +224,10 @@ orderby item select item; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task DontWarnOnOrderByDescendingOnlyQueryAsync() => await VerifyAsync(""" + public Task DontWarnOnOrderByDescendingOnlyQueryAsync() => VerifyAsync(""" using System.Linq; using System.Collections.Generic; @@ -241,10 +241,10 @@ orderby item descending select item; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task DontWarnOnRightOrderQueryAsync() => await VerifyAsync(""" + public Task DontWarnOnRightOrderQueryAsync() => VerifyAsync(""" using System.Linq; using System.Collections.Generic; @@ -259,10 +259,10 @@ orderby item select item; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task WarnOnWrongOrderQueryAsync() => await VerifyAsync(""" + public Task WarnOnWrongOrderQueryAsync() => VerifyAsync(""" using System.Linq; using System.Collections.Generic; @@ -292,10 +292,10 @@ orderby item select item; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task WarnOnWrongMultipleOrderQueryAsync() => await VerifyAsync(""" + public Task WarnOnWrongMultipleOrderQueryAsync() => VerifyAsync(""" using System.Linq; using System.Collections.Generic; @@ -327,10 +327,10 @@ orderby item.B select item; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task DontWarnOnDisjointedOrderQueryAsync() => await VerifyAsync(""" + public Task DontWarnOnDisjointedOrderQueryAsync() => VerifyAsync(""" using System.Linq; using System.Collections.Generic; @@ -347,10 +347,10 @@ where item > 0 select item; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task WarnOnWrongOrderDescendingQueryAsync() => await VerifyAsync(""" + public Task WarnOnWrongOrderDescendingQueryAsync() => VerifyAsync(""" using System.Linq; using System.Collections.Generic; @@ -380,10 +380,10 @@ orderby item descending select item; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task DontWarnOnDisjointedOrderDescendingQueryAsync() => await VerifyAsync(""" + public Task DontWarnOnDisjointedOrderDescendingQueryAsync() => VerifyAsync(""" using System.Linq; using System.Collections.Generic; @@ -400,10 +400,10 @@ where item > 0 select item; } } - """).ConfigureAwait(false); + """); [TestMethod] - public async Task WarnOnWrongMultipleOrderDescendingQueryAsync() => await VerifyAsync(""" + public Task WarnOnWrongMultipleOrderDescendingQueryAsync() => VerifyAsync(""" using System.Linq; using System.Collections.Generic; @@ -435,7 +435,7 @@ orderby item.B descending select item; } } - """).ConfigureAwait(false); + """); #endregion } diff --git a/src/EcoCode.Tests/Tests/EC93.ReturnTaskDirectly.Tests.cs b/src/EcoCode.Tests/Tests/EC93.ReturnTaskDirectly.Tests.cs index a5298464..ab6af1a9 100644 --- a/src/EcoCode.Tests/Tests/EC93.ReturnTaskDirectly.Tests.cs +++ b/src/EcoCode.Tests/Tests/EC93.ReturnTaskDirectly.Tests.cs @@ -6,7 +6,7 @@ public sealed class ReturnTaskDirectlyTests private static readonly CodeFixerDlg VerifyAsync = TestRunner.VerifyAsync; [TestMethod] - public async Task EmptyCodeAsync() => await VerifyAsync("").ConfigureAwait(false); + public Task EmptyCodeAsync() => VerifyAsync(""); [TestMethod] public Task DontWarnWhenReturningTask1Async() => VerifyAsync("""