Implement LuceneDev4000-4002 NoInlining Analyzers & CodeFix (#1097)

Adds three Roslyn analyzers under the new Performance category covering
[MethodImpl(MethodImplOptions.NoInlining)] usage:

- LuceneDev4000: Reports when NoInlining is applied to an interface or
  abstract method. The MethodImpl attribute is not inherited, so the
  attribute has no effect on the implementation.
- LuceneDev4001: Reports when NoInlining is applied to an empty-bodied
  method. An empty body cannot appear above any frame in a stack trace,
  so preventing inlining provides no benefit.
- LuceneDev4002: Reports when a method referenced by the 2-argument
  StackTraceHelper.DoesStackTraceContainMethod(className, methodName)
  overload is missing NoInlining. Without it, the JIT may inline the
  method out of the stack trace, silently breaking the check.

A code fix is provided for 4000 and 4001 (remove the attribute). 4002
has no automated fix because the diagnostic is reported on a method
declaration triggered by an invocation in another scope, which Roslyn
treats as a non-local diagnostic and refuses to fix automatically.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: paulirwin

src/Lucene.Net.CodeAnalysis.Dev.CodeFixes/LuceneDev4xxx/LuceneDev4000_4001_4002_NoInliningCodeFixProvider.cs

@@ -0,0 +1,98 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using System.Collections.Immutable;
+using System.Composition;
+using System.Threading;
+using System.Threading.Tasks;
+using Lucene.Net.CodeAnalysis.Dev.Utility;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Lucene.Net.CodeAnalysis.Dev.CodeFixes.LuceneDev4xxx
+{
+    [ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(LuceneDev4000_4001_4002_NoInliningCodeFixProvider)), Shared]
+    public sealed class LuceneDev4000_4001_4002_NoInliningCodeFixProvider : CodeFixProvider
+    {
+        private const string TitleRemoveAttribute = "Remove [MethodImpl(MethodImplOptions.NoInlining)]";
+
+        // Note: LuceneDev4002 has no code fix here. Its diagnostic is reported on the
+        // referenced method declaration but is triggered from a separate
+        // StackTraceHelper.DoesStackTraceContainMethod invocation — Roslyn treats this
+        // as a "non-local" diagnostic, which the code fix pipeline does not permit
+        // fixing automatically. The IDE still surfaces the warning on the declaration
+        // and the user adds the attribute manually.
+        public override ImmutableArray<string> FixableDiagnosticIds =>
+            ImmutableArray.Create(
+                Descriptors.LuceneDev4000_NoInliningHasNoEffect.Id,
+                Descriptors.LuceneDev4001_NoInliningOnEmptyMethod.Id);
+
+        public override FixAllProvider GetFixAllProvider() => WellKnownFixAllProviders.BatchFixer;
+
+        public override async Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+            if (root is null)
+                return;
+
+            var diagnostic = context.Diagnostics[0];
+            var node = root.FindNode(diagnostic.Location.SourceSpan, getInnermostNodeForTie: true);
+
+            var attribute = node as AttributeSyntax
+                ?? node.FirstAncestorOrSelf<AttributeSyntax>();
+            if (attribute is null)
+                return;
+
+            context.RegisterCodeFix(
+                CodeAction.Create(
+                    TitleRemoveAttribute,
+                    ct => RemoveAttributeAsync(context.Document, attribute, ct),
+                    equivalenceKey: nameof(TitleRemoveAttribute) + diagnostic.Id),
+                diagnostic);
+        }
+
+        private static async Task<Document> RemoveAttributeAsync(
+            Document document,
+            AttributeSyntax attribute,
+            CancellationToken cancellationToken)
+        {
+            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            if (root is null)
+                return document;
+
+            if (attribute.Parent is AttributeListSyntax attrList)
+            {
+                SyntaxNode newRoot;
+                if (attrList.Attributes.Count == 1)
+                {
+                    newRoot = root.RemoveNode(attrList, SyntaxRemoveOptions.KeepNoTrivia)!;
+                }
+                else
+                {
+                    var newList = attrList.WithAttributes(attrList.Attributes.Remove(attribute));
+                    newRoot = root.ReplaceNode(attrList, newList);
+                }
+                return document.WithSyntaxRoot(newRoot);
+            }
+
+            return document;
+        }
+    }
+}

src/Lucene.Net.CodeAnalysis.Dev/AnalyzerReleases.Unshipped.md

@@ -4,6 +4,9 @@ Rule ID       | Category | Severity | Notes
 --------------|----------|----------|-----------------------------------------------------------------------------------------------------------------------------------------------------------
 LuceneDev1007 | Design   | Warning  | Generic Dictionary<TKey, TValue> indexer should not be used to retrieve values because it may throw KeyNotFoundException (value type value)
 LuceneDev1008 | Design   | Warning  | Generic Dictionary<TKey, TValue> indexer should not be used to retrieve values because it may throw KeyNotFoundException (reference type value)
+LuceneDev4000 | Performance | Warning | [MethodImpl(MethodImplOptions.NoInlining)] has no effect on interface or abstract methods (the attribute is not inherited)
+LuceneDev4001 | Performance | Warning | [MethodImpl(MethodImplOptions.NoInlining)] should not be used on empty-bodied methods (no benefit, harms performance)
+LuceneDev4002 | Performance | Warning | Methods referenced by the 2-argument StackTraceHelper.DoesStackTraceContainMethod overload should be marked [MethodImpl(MethodImplOptions.NoInlining)] when the method body is non-empty
 LuceneDev6000 | Usage    | Info     | IDictionary indexer may be used to retrieve values, but must be checked for null before using the value
 LuceneDev6001 | Usage    | Error    | Missing StringComparison argument in String overloads of StartsWith/EndsWith/IndexOf/LastIndexOf; must use Ordinal/OrdinalIgnoreCase
 LuceneDev6002 | Usage    | Error    | Invalid StringComparison value in String overloads of StartsWith/EndsWith/IndexOf/LastIndexOf; only Ordinal/OrdinalIgnoreCase allowed