Adds 💡 Implement Using Copilot for NotImplementedException

src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems

@@ -27,6 +27,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)ConvertProgram\ConvertProgramAnalysis_ProgramMain.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ConvertProgram\ConvertToTopLevelStatementsDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ConvertTypeofToNameof\CSharpConvertTypeOfToNameOfDiagnosticAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Copilot\CSharpImplementNotImplementedExceptionDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ForEachCast\CSharpForEachCastDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Formatting\CSharpFormattingAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)MakeAnonymousFunctionStatic\MakeAnonymousFunctionStaticDiagnosticAnalyzer.cs" />

src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx

@@ -431,4 +431,7 @@
   <data name="Use_unbound_generic_type" xml:space="preserve">
     <value>Use unbound generic type</value>
   </data>
+  <data name="Implement_with_Copilot" xml:space="preserve">
+    <value>Implement with Copilot</value>
+  </data>
 </root>

src/Analyzers/CSharp/Analyzers/Copilot/CSharpImplementNotImplementedExceptionDiagnosticAnalyzer.cs

@@ -0,0 +1,59 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Operations;
+
+namespace Microsoft.CodeAnalysis.CSharp.Copilot;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+internal sealed class CSharpImplementNotImplementedExceptionDiagnosticAnalyzer()
+    : AbstractBuiltInCodeStyleDiagnosticAnalyzer(
+        IDEDiagnosticIds.CopilotImplementNotImplementedExceptionDiagnosticId,
+        EnforceOnBuildValues.CopilotImplementNotImplementedException,
+        option: null,
+        new LocalizableResourceString(
+            nameof(CSharpAnalyzersResources.Implement_with_Copilot), CSharpAnalyzersResources.ResourceManager, typeof(CSharpAnalyzersResources)),
+        configurable: false)
+{
+    public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
+        => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
+
+    protected override void InitializeWorker(AnalysisContext context)
+    {
+        context.RegisterCompilationStartAction(context =>
+        {
+            var fullName = typeof(NotImplementedException).FullName;
+            Contract.ThrowIfNull(fullName);
+            var notImplementedExceptionType = context.Compilation.GetTypeByMetadataName(fullName);
+            if (notImplementedExceptionType != null)
+                context.RegisterOperationAction(context => AnalyzeThrow(context, notImplementedExceptionType), OperationKind.Throw);
+        });
+    }
+
+    private void AnalyzeThrow(OperationAnalysisContext context, INamedTypeSymbol notImplementedExceptionType)
+    {
+        var throwOperation = (IThrowOperation)context.Operation;
+        if (throwOperation is
+            {
+                Exception: IConversionOperation
+                {
+                    Operand: IObjectCreationOperation
+                    {
+                        Constructor.ContainingType: INamedTypeSymbol constructedType,
+                    },
+                },
+                Syntax: ThrowExpressionSyntax or ThrowStatementSyntax,
+            } &&
+            notImplementedExceptionType.Equals(constructedType))
+        {
+            context.ReportDiagnostic(Diagnostic.Create(
+                Descriptor,
+                throwOperation.Syntax.GetLocation()));
+        }
+    }
+}

src/Analyzers/CSharp/Tests/CSharpAnalyzers.UnitTests.projitems

@@ -20,6 +20,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)AliasAmbiguousType\AliasAmbiguousTypeTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)AssignOutParameters\AssignOutParametersAboveReturnTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)AssignOutParameters\AssignOutParametersAtStartTests.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)Copilot\CSharpImplementNotImplementedExceptionDiagnosticAnalyzerTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)DocumentationComments\AddDocCommentNodesCodeFixProviderTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)DocumentationComments\RemoveDocCommentNodeCodeFixProviderTests.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ConditionalExpressionInStringInterpolation\CSharpAddParenthesesAroundConditionalExpressionInInterpolatedStringCodeFixProviderTests.cs" />
@@ -202,6 +203,7 @@
   </ItemGroup>
   <ItemGroup>
     <Folder Include="$(MSBuildThisFileDirectory)AbstractBuiltInCodeStyleDiagnosticAnalyzer\" />
+    <Folder Include="$(MSBuildThisFileDirectory)Copilot\" />
     <Folder Include="$(MSBuildThisFileDirectory)UseImplicitlyTypedLambdaExpression\" />
   </ItemGroup>
 </Project>

src/Analyzers/CSharp/Tests/Copilot/CSharpImplementNotImplementedExceptionDiagnosticAnalyzerTests.cs

@@ -0,0 +1,139 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.Editor.UnitTests.CodeActions;
+using Microsoft.CodeAnalysis.Testing;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.Copilot.UnitTests;
+
+using VerifyCS = CSharpCodeFixVerifier<
+    CSharpImplementNotImplementedExceptionDiagnosticAnalyzer,
+    EmptyCodeFixProvider>;
+
+public class CSharpImplementNotImplementedExceptionDiagnosticAnalyzerTests
+{
+    [Fact]
+    public async Task TestThrowNotImplementedExceptionInStatement()
+    {
+        var testCode = """
+            using System;
+
+            class C
+            {
+                void M()
+                {
+                    {|IDE3000:throw new NotImplementedException();|}
+                }
+            }
+            """;
+
+        await new VerifyCS.Test
+        {
+            TestCode = testCode,
+            LanguageVersion = LanguageVersion.CSharp11,
+            ReferenceAssemblies = ReferenceAssemblies.Net.Net60,
+        }.RunAsync();
+    }
+
+    [Fact]
+    public async Task TestThrowNotImplementedExceptionInExpression()
+    {
+        var testCode = """
+            using System;
+
+            class C
+            {
+                int P => {|IDE3000:throw new NotImplementedException()|};
+            }
+            """;
+
+        await new VerifyCS.Test
+        {
+            TestCode = testCode,
+            LanguageVersion = LanguageVersion.CSharp11,
+            ReferenceAssemblies = ReferenceAssemblies.Net.Net60,
+        }.RunAsync();
+    }
+
+    [Fact]
+    public async Task TestDifferentFlavorsOfThrowNotImplementedException()
+    {
+        var testCode = """
+            using System;
+
+            class C
+            {
+                void M1()
+                {
+                    {|IDE3000:throw new NotImplementedException("Not implemented");|}
+                }
+
+                void M2()
+                {
+                    {|IDE3000:throw new NotImplementedException("Not implemented");|}
+                }
+
+                void M3()
+                {
+                    try
+                    {
+                        // Some code
+                    }
+                    catch (Exception)
+                    {
+                        {|IDE3000:throw new NotImplementedException();|}
+                    }
+                }
+
+                int P1
+                {
+                    get { {|IDE3000:throw new NotImplementedException();|} }
+                }
+
+                int P2
+                {
+                    get { {|IDE3000:throw new NotImplementedException();|} }
+                    set { {|IDE3000:throw new NotImplementedException();|} }
+                }
+
+                int this[int index]
+                {
+                    get { {|IDE3000:throw new NotImplementedException();|} }
+                    set { {|IDE3000:throw new NotImplementedException();|} }
+                }
+
+                void M4()
+                {
+                    Action action = () => {|IDE3000:throw new NotImplementedException()|};
+                    action();
+                }
+
+                void M5()
+                {
+                    Func<int> func = () => {|IDE3000:throw new NotImplementedException()|};
+                    func();
+                }
+
+                void M6()
+                {
+                    {|IDE3000:throw new NotImplementedException();|}
+                }
+
+                void M7()
+                {
+                    {|IDE3000:throw new NotImplementedException("Not implemented");|}
+                }
+            }
+            """;
+
+        await new VerifyCS.Test
+        {
+            TestCode = testCode,
+            LanguageVersion = LanguageVersion.CSharp11,
+            ReferenceAssemblies = ReferenceAssemblies.Net.Net60,
+        }.RunAsync();
+    }
+}

src/Analyzers/Core/Analyzers/EnforceOnBuildValues.cs

@@ -140,6 +140,7 @@ internal static class EnforceOnBuildValues
     public const EnforceOnBuild ConvertAnonymousTypeToTuple = /*IDE0050*/ EnforceOnBuild.Never;
     public const EnforceOnBuild RemoveUnreachableCode = /*IDE0035*/ EnforceOnBuild.Never; // Non-configurable fading diagnostic corresponding to CS0162.
     public const EnforceOnBuild RemoveUnnecessarySuppression = /*IDE0079*/ EnforceOnBuild.Never; // IDE-only analyzer.
+    public const EnforceOnBuild CopilotImplementNotImplementedException = /*IDE3000*/ EnforceOnBuild.Never; // IDE-only analyzer.
 
     // Pure IDE feature for lighting up editor features.  Do not enforce on build.
     public const EnforceOnBuild DetectProbableJsonStrings = /*JSON002*/ EnforceOnBuild.Never;