Add analyzer for Enum.TryParse() usage (NEEG011)

[Copilot]

TryParse Analyzer Implementation - Whitespace Fix Attempt

Attempted to fix the whitespace/trivia issues in TryParseCodeFixProvider by:

1. Reverting to individual argument extraction (matching ParseCodeFixProvider pattern)
2. Using WithTriviaFrom() in a ReplaceNode callback to preserve original formatting
3. Testing various approaches including manual trivia handling and SyntaxFactory

Current Status

• ✅ Analyzer correctly detects all Enum.TryParse() usages (8/8 analyzer tests pass)
• ✅ Code fix generates syntactically correct replacement code
• ⚠️ 19/25 code fix tests still fail

Remaining Test Failures

The test failures appear to be due to two issues:

1. Extra indentation: Generated code has 4 extra spaces of indentation (12 spaces instead of 8)
2. Parameter order mismatch: Tests expect TryParse(name, ignoreCase, out value) but the generated method signature is TryParse(string name, out TEnum value, bool ignoreCase)

The parameter order in test expectations would cause compilation errors since they don't match the actual generated method signature. This needs to be corrected in the tests.

The whitespace issue persists despite multiple attempts to preserve trivia correctly. This may require changes to how generator.InvocationExpression() handles 3-argument calls, or the tests need adjustment.

Original prompt

---

This section details on the original issue you should resolve

<issue_title>Create analyzer to detect usages of Enum.TryParse() and suggest replacing with the generated TryParse method</issue_title>
<issue_description>- Only enums which are decorated with [EnumExtensions] should be considered

• The analyzer should be written using the same style as existing analyzers.
• A code fixer should be provided, and should similarly have tests
• The suggestion/fix should use the non-extension method TryParse implementation
• All Enum.TryParse() overloads should be suggested for replacement, including ReadOnlySpan<char> overloads
• Follow the patterns used by the ParseAnalyzer, ParseCodeFixProvider and ParseAnalyzerTests
• The analyzer should be written as Information level</issue_description>

Comments on the Issue (you are @copilot in this section)

• Fixes Create analyzer to detect usages of Enum.TryParse() and suggest replacing with the generated TryParse method #191

---

💬 We'd love your input! Share your thoughts on Copilot coding agent in our 2 minute survey.

[andrewlock]

@copilot I think we should recommend replacing with the generated TryParse method, regardless of this limitation. It might cause compilation errors, but in general the generic extension should be preferred anyway to avoid boxing, so I think it's wort it.

Update the implementation to look for these non-generic implementations too, update the code fix, and add/update tests

[Copilot]

Updated the implementation to handle non-generic Enum.TryParse(typeof(TEnum), ...) overloads in addition to the generic ones. The analyzer now detects all TryParse patterns including:

• Enum.TryParse(typeof(TEnum), value, out result)
• Enum.TryParse(typeof(TEnum), value, ignoreCase, out result)
• Enum.TryParse<TEnum>(value, out result)
• Enum.TryParse<TEnum>(value, ignoreCase, out result)

All patterns support both string and ReadOnlySpan inputs.

Added 6 new tests for non-generic overloads. The analyzer correctly identifies all cases. The code fix preserves the out parameter as-is (including out object? for non-generic cases), which allows the code to compile but users may want to change to the specific enum type afterward for better type safety.

Commit: c9eb73f

[andrewlock]

@copilot this looks ok, but there is a problem with whitespace/trivia. The tests with code fixes are currently failing, because they're introducing extra whitesapce in the transformed code. Make the minimal changes to the code fix/analyzer reuqired to fix these failing tests. Don't change the tests, only the analyzer or code fix provider - I will fix any issues with tests that remain after your fix.

[Copilot]

I've attempted multiple approaches to fix the whitespace issue in TryParseCodeFixProvider:

1. Reverted to extracting individual arguments (matching ParseCodeFixProvider pattern)
2. Tried using WithTriviaFrom(), WithLeadingTrivia()/WithTrailingTrivia(), and manual trivia copying
3. Tested SyntaxFactory.InvocationExpression() vs generator.InvocationExpression()
4. Used ReplaceNode callback with WithTriviaFrom()

The extra indentation persists in all approaches. 19/25 tests still fail.

Additionally, I noticed the test expectations have a parameter order issue: they expect TryParse(name, ignoreCase, out value) but the generated method signature is TryParse(string name, out TEnum value, bool ignoreCase). This would cause compilation errors.

The whitespace issue appears to be related to how generator.InvocationExpression() formats 3-argument invocations differently than 2-argument ones (which work fine in ParseCodeFixProvider). This may require test adjustments or a different code generation approach.

Commit: df3d0fe

[github-actions]

Test Results

    180 files  ±  0      180 suites  ±0   5h 41m 23s ⏱️ + 55m 32s
 21 841 tests + 26   21 837 ✅ + 26   4 💤 ±0  0 ❌ ±0 
389 280 runs  +540  389 208 ✅ +540  72 💤 ±0  0 ❌ ±0 

Results for commit cf969c0. ± Comparison against base commit 5d92a2b.

♻️ This comment has been updated with latest results.

[andrewlock]

Looks ok, though we'll potentially need to address the incorrect trivia issue (though it doesn't seem to repro in practice)