Add CA2024: Do not use 'StreamReader.EndOfStream' in async methods (#…

…7390) * Add CA2024: Do not use 'StreamReader.EndOfStream' in async methods This analyzer detects when 'StreamReader.EndOfStream' is used in an async method, which can prevent I/O from being done asynchronously. * Use VerifyAnalyzerAsync instead of VerifyCodeFixAsync * Explicitly specify diagnostic ID in test markup * Check symbols first before checking async context Using the Stream type, or more specifically, the EndOfStream property of the Stream type, should be much rarer than async methods in general, so we check the symbols first. * Remove IsAsyncContext * Remove unnecessary containing type check
dotnet · Nov 9, 2024 · 5435ba7 · 5435ba7
1 parent d6e7d82
commit 5435ba7
Show file tree

Hide file tree

Showing 22 changed files with 811 additions and 1 deletion.
diff --git a/src/NetAnalyzers/Core/AnalyzerReleases.Unshipped.md b/src/NetAnalyzers/Core/AnalyzerReleases.Unshipped.md
@@ -5,3 +5,4 @@
 Rule ID | Category | Severity | Notes
 --------|----------|----------|-------
 CA2023 | Reliability | Warning | LoggerMessageDefineAnalyzer, [Documentation](https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca2023)
+CA2024 | Reliability | Warning | DoNotUseEndOfStreamInAsyncMethods, [Documentation](https://learn.microsoft.com/dotnet/fundamentals/code-analysis/quality-rules/ca2024)
diff --git a/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/MicrosoftNetCoreAnalyzersResources.resx b/src/NetAnalyzers/Core/Microsoft.NetCore.Analyzers/MicrosoftNetCoreAnalyzersResources.resx
@@ -281,6 +281,15 @@
   <data name="DoNotRaiseReservedExceptionTypesMessageReserved" xml:space="preserve">
     <value>Exception type {0} is reserved by the runtime</value>
   </data>
+  <data name="DoNotUseEndOfStreamInAsyncMethodsTitle" xml:space="preserve">
+    <value>Do not use 'StreamReader.EndOfStream' in async methods</value>
+  </data>
+  <data name="DoNotUseEndOfStreamInAsyncMethodsDescription" xml:space="preserve">
+    <value>The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</value>
+  </data>
+  <data name="DoNotUseEndOfStreamInAsyncMethodsMessage" xml:space="preserve">
+    <value>Do not use '{0}' in an async method</value>
+  </data>
   <data name="InitializeValueTypeStaticFieldsInlineTitle" xml:space="preserve">
     <value>Initialize value type static fields inline</value>
   </data>

diff --git a/...etAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/DoNotUseEndOfStreamInAsyncMethods.cs b/...etAnalyzers/Core/Microsoft.NetCore.Analyzers/Runtime/DoNotUseEndOfStreamInAsyncMethods.cs
@@ -0,0 +1,81 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the MIT license.  See License.txt in the project root for license information.
+
+using System.Collections.Immutable;
+using System.Linq;
+using Analyzer.Utilities;
+using Analyzer.Utilities.Extensions;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+
+namespace Microsoft.NetCore.Analyzers.Runtime
+{
+    using static MicrosoftNetCoreAnalyzersResources;
+
+    /// <summary>
+    /// CA2024: <inheritdoc cref="DoNotUseEndOfStreamInAsyncMethodsTitle"/>
+    /// </summary>
+    [DiagnosticAnalyzer(LanguageNames.CSharp, LanguageNames.VisualBasic)]
+    public sealed class DoNotUseEndOfStreamInAsyncMethodsAnalyzer : DiagnosticAnalyzer
+    {
+        private const string RuleId = "CA2024";
+        private const string EndOfStream = nameof(EndOfStream);
+
+        private static readonly DiagnosticDescriptor Rule = DiagnosticDescriptorHelper.Create(
+            RuleId,
+            CreateLocalizableResourceString(nameof(DoNotUseEndOfStreamInAsyncMethodsTitle)),
+            CreateLocalizableResourceString(nameof(DoNotUseEndOfStreamInAsyncMethodsMessage)),
+            DiagnosticCategory.Reliability,
+            RuleLevel.BuildWarning,
+            CreateLocalizableResourceString(nameof(DoNotUseEndOfStreamInAsyncMethodsDescription)),
+            isPortedFxCopRule: false,
+            isDataflowRule: false);
+
+        public sealed override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } = ImmutableArray.Create(Rule);
+
+        public sealed override void Initialize(AnalysisContext context)
+        {
+            context.EnableConcurrentExecution();
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+            context.RegisterCompilationStartAction(OnCompilationStart);
+        }
+
+        private void OnCompilationStart(CompilationStartAnalysisContext context)
+        {
+            var streamReaderType = context.Compilation.GetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemIOStreamReader);
+
+            if (streamReaderType is null)
+            {
+                return;
+            }
+
+            var endOfStreamProperty = streamReaderType.GetMembers(EndOfStream)
+                .OfType<IPropertySymbol>()
+                .FirstOrDefault();
+
+            if (endOfStreamProperty is null)
+            {
+                return;
+            }
+
+            context.RegisterOperationAction(AnalyzePropertyReference, OperationKind.PropertyReference);
+
+            void AnalyzePropertyReference(OperationAnalysisContext context)
+            {
+                var operation = (IPropertyReferenceOperation)context.Operation;
+
+                if (!SymbolEqualityComparer.Default.Equals(endOfStreamProperty, operation.Member))
+                {
+                    return;
+                }
+
+                var containingSymbol = operation.TryGetContainingAnonymousFunctionOrLocalFunction() ?? context.ContainingSymbol;
+
+                if (containingSymbol is IMethodSymbol containingMethod && containingMethod.IsAsync)
+                {
+                    context.ReportDiagnostic(operation.CreateDiagnostic(Rule, operation.Syntax.ToString()));
+                }
+            }
+        }
+    }
+}
diff --git a/...tAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.cs.xlf b/...tAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.cs.xlf
@@ -1088,6 +1088,21 @@ Obecné přetypování (IL unbox.any) používané sekvencí vrácenou metodou E
         <target state="translated">Pevně zakódované použití zastaralého protokolu zabezpečení {0}</target>
         <note />
       </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsDescription">
+        <source>The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</source>
+        <target state="new">The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsMessage">
+        <source>Do not use '{0}' in an async method</source>
+        <target state="new">Do not use '{0}' in an async method</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsTitle">
+        <source>Do not use 'StreamReader.EndOfStream' in async methods</source>
+        <target state="new">Do not use 'StreamReader.EndOfStream' in async methods</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DoNotUseEnumerableMethodsOnIndexableCollectionsInsteadUseTheCollectionDirectlyDescription">
         <source>This collection is directly indexable. Going through LINQ here causes unnecessary allocations and CPU work.</source>
         <target state="translated">Tato kolekce se dá přímo indexovat. Procházení kódu LINQ na tomto místě způsobuje zbytečné alokace a vytížení procesoru.</target>

diff --git a/...tAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.de.xlf b/...tAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.de.xlf
@@ -1088,6 +1088,21 @@ Erweiterungen und benutzerdefinierte Konvertierungen werden bei generischen Type
         <target state="translated">Hartcodierte Verwendung des veralteten Sicherheitsprotokolls "{0}"</target>
         <note />
       </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsDescription">
+        <source>The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</source>
+        <target state="new">The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsMessage">
+        <source>Do not use '{0}' in an async method</source>
+        <target state="new">Do not use '{0}' in an async method</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsTitle">
+        <source>Do not use 'StreamReader.EndOfStream' in async methods</source>
+        <target state="new">Do not use 'StreamReader.EndOfStream' in async methods</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DoNotUseEnumerableMethodsOnIndexableCollectionsInsteadUseTheCollectionDirectlyDescription">
         <source>This collection is directly indexable. Going through LINQ here causes unnecessary allocations and CPU work.</source>
         <target state="translated">Diese Sammlung kann direkt indiziert werden. Der Umweg über LINQ verursacht in diesem Fall unnötige Zuordnungen und CPU-Last.</target>

diff --git a/...tAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.es.xlf b/...tAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.es.xlf
@@ -1088,6 +1088,21 @@ La ampliación y las conversiones definidas por el usuario no se admiten con tip
         <target state="translated">Uso codificado de forma rígida de un protocolo de seguridad en desuso {0}</target>
         <note />
       </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsDescription">
+        <source>The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</source>
+        <target state="new">The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsMessage">
+        <source>Do not use '{0}' in an async method</source>
+        <target state="new">Do not use '{0}' in an async method</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsTitle">
+        <source>Do not use 'StreamReader.EndOfStream' in async methods</source>
+        <target state="new">Do not use 'StreamReader.EndOfStream' in async methods</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DoNotUseEnumerableMethodsOnIndexableCollectionsInsteadUseTheCollectionDirectlyDescription">
         <source>This collection is directly indexable. Going through LINQ here causes unnecessary allocations and CPU work.</source>
         <target state="translated">Esta colección es directamente indexable. Pasar por LINQ en este caso genera asignaciones y trabajo de CPU innecesarios.</target>

diff --git a/...tAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.fr.xlf b/...tAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.fr.xlf
@@ -1088,6 +1088,21 @@ Les conversions étendues et définies par l’utilisateur ne sont pas prises en
         <target state="translated">Utilisation codée en dur du protocole de sécurité déprécié {0}</target>
         <note />
       </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsDescription">
+        <source>The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</source>
+        <target state="new">The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsMessage">
+        <source>Do not use '{0}' in an async method</source>
+        <target state="new">Do not use '{0}' in an async method</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsTitle">
+        <source>Do not use 'StreamReader.EndOfStream' in async methods</source>
+        <target state="new">Do not use 'StreamReader.EndOfStream' in async methods</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DoNotUseEnumerableMethodsOnIndexableCollectionsInsteadUseTheCollectionDirectlyDescription">
         <source>This collection is directly indexable. Going through LINQ here causes unnecessary allocations and CPU work.</source>
         <target state="translated">Cette collection est directement indexable. L'utilisation de LINQ ici entraîne des allocations non nécessaires et une sollicitation inutile de l'UC.</target>

diff --git a/...tAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.it.xlf b/...tAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.it.xlf
@@ -1088,6 +1088,21 @@ L'ampliamento e le conversioni definite dall'utente non sono supportate con tipi
         <target state="translated">Uso hardcoded del protocollo di sicurezza deprecato {0}</target>
         <note />
       </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsDescription">
+        <source>The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</source>
+        <target state="new">The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsMessage">
+        <source>Do not use '{0}' in an async method</source>
+        <target state="new">Do not use '{0}' in an async method</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsTitle">
+        <source>Do not use 'StreamReader.EndOfStream' in async methods</source>
+        <target state="new">Do not use 'StreamReader.EndOfStream' in async methods</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DoNotUseEnumerableMethodsOnIndexableCollectionsInsteadUseTheCollectionDirectlyDescription">
         <source>This collection is directly indexable. Going through LINQ here causes unnecessary allocations and CPU work.</source>
         <target state="translated">Questa raccolta è direttamente indicizzabile. L'uso di LINQ in questo punto causa un carico della CPU e allocazioni non necessarie.</target>

diff --git a/...tAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.ja.xlf b/...tAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.ja.xlf
@@ -1088,6 +1088,21 @@ Enumerable.OfType&lt;T&gt; で使用されるジェネリック型チェック (
         <target state="translated">非推奨のセキュリティ プロトコル {0} のハードコーディングされた使用</target>
         <note />
       </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsDescription">
+        <source>The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</source>
+        <target state="new">The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsMessage">
+        <source>Do not use '{0}' in an async method</source>
+        <target state="new">Do not use '{0}' in an async method</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsTitle">
+        <source>Do not use 'StreamReader.EndOfStream' in async methods</source>
+        <target state="new">Do not use 'StreamReader.EndOfStream' in async methods</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DoNotUseEnumerableMethodsOnIndexableCollectionsInsteadUseTheCollectionDirectlyDescription">
         <source>This collection is directly indexable. Going through LINQ here causes unnecessary allocations and CPU work.</source>
         <target state="translated">このコレクションは、直接インデックス可能です。ここで LINQ を実行すると、不要な割り当てと CPU 作業が生じます。</target>

diff --git a/...tAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.ko.xlf b/...tAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.ko.xlf
@@ -1088,6 +1088,21 @@ Enumerable.OfType&lt;T&gt;에서 사용하는 제네릭 형식 검사(C# 'is'
         <target state="translated">사용되지 않는 보안 프로토콜 {0}의 하드 코드된 사용</target>
         <note />
       </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsDescription">
+        <source>The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</source>
+        <target state="new">The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsMessage">
+        <source>Do not use '{0}' in an async method</source>
+        <target state="new">Do not use '{0}' in an async method</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsTitle">
+        <source>Do not use 'StreamReader.EndOfStream' in async methods</source>
+        <target state="new">Do not use 'StreamReader.EndOfStream' in async methods</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DoNotUseEnumerableMethodsOnIndexableCollectionsInsteadUseTheCollectionDirectlyDescription">
         <source>This collection is directly indexable. Going through LINQ here causes unnecessary allocations and CPU work.</source>
         <target state="translated">이 컬렉션을 직접 인덱싱할 수 있습니다. 여기에서 LINQ를 통과하면 불필요한 할당과 CPU 작업이 발생합니다.</target>

diff --git a/...tAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.pl.xlf b/...tAnalyzers/Core/Microsoft.NetCore.Analyzers/xlf/MicrosoftNetCoreAnalyzersResources.pl.xlf
@@ -1088,6 +1088,21 @@ Konwersje poszerzane i zdefiniowane przez użytkownika nie są obsługiwane w pr
         <target state="translated">Zakodowane korzystanie z przestarzałego protokołu zabezpieczeń {0}</target>
         <note />
       </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsDescription">
+        <source>The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</source>
+        <target state="new">The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsMessage">
+        <source>Do not use '{0}' in an async method</source>
+        <target state="new">Do not use '{0}' in an async method</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="DoNotUseEndOfStreamInAsyncMethodsTitle">
+        <source>Do not use 'StreamReader.EndOfStream' in async methods</source>
+        <target state="new">Do not use 'StreamReader.EndOfStream' in async methods</target>
+        <note />
+      </trans-unit>
       <trans-unit id="DoNotUseEnumerableMethodsOnIndexableCollectionsInsteadUseTheCollectionDirectlyDescription">
         <source>This collection is directly indexable. Going through LINQ here causes unnecessary allocations and CPU work.</source>
         <target state="translated">Tę kolekcję można zaindeksować bezpośrednio. Użycie w tym miejscu kodu LINQ powoduje niepotrzebne alokacje i obciążenie procesora CPU.</target>