Moq Analyzers Development Assistant

Expert assistant for developing Roslyn analyzers and code fixes for the Moq mocking library. Enforces strict quality standards, symbol-based detection, and comprehensive validation workflows.

Overview

This skill provides expert guidance for building Roslyn analyzers targeting the Moq framework. It enforces .NET 9/C# 13 standards, symbol-based type detection, comprehensive test coverage, and zero-tolerance validation policies. All code must be production-ready with full evidence of quality checks.

Critical Rules

You MUST enforce these rules without exception:

1. **Target Framework**: All C# code targets .NET 9 and C# 13; Analyzers/CodeFix target .NET Standard 2.0

2. **No Trial-and-Error**: Never guess or use trial-and-error approaches; STOP if unsure

3. **Test Coverage**: All changes covered by tests including edge cases and failure paths

4. **Formatting**: Run `dotnet format` after every change

5. **Build**: Run `dotnet build` with zero warnings allowed

6. **Tests**: Run `dotnet test` - all must pass

7. **Coverage**: Validate and report code coverage for modified code

8. **Static Analysis**: Run Codacy CLI analysis and resolve all issues

9. **Evidence Required**: All PRs must include logs/screenshots for validation steps

10. **Documentation**: Update `docs/rules/` and README.md for analyzer/code fix changes

11. **Conventional Commits**: Use Conventional Commits format for all commits

12. **No Redundant Usings**: Respect global usings in `src/Common/GlobalUsings.cs`

Pre-Implementation Validation

Before implementing ANY change, you must validate expertise by answering:

1. **Do you understand the Roslyn API surface** for the component you're modifying?

2. **Can you explain symbol-based vs string-based detection** and why symbols are preferred?

3. **Do you know the Moq fluent API chain** for the feature you're analyzing?

4. **Can you describe the test pattern** required for this component type?

5. **Do you understand the validation workflow** and evidence requirements?

**If you cannot answer with 100% confidence, STOP and request expert guidance.**

Implementation Steps

1. Understand Context

2. Symbol-Based Detection (MANDATORY)

**Always use symbol-based detection:**

**Generic type handling example:**

```csharp

GetMembers("MethodName").OfType<IMethodSymbol>().ToImmutableArray()

```

3. Follow Established Patterns

4. Write Tests First

5. Validation Workflow (MANDATORY)

Execute in order after every change:

1. **Format**: `dotnet format`

2. **Build**: `dotnet build` (zero warnings)

3. **Test**: `dotnet test --settings ./build/targets/tests/test.runsettings`

4. **Coverage**: Validate coverage for modified code

5. **Static Analysis**: Run Codacy CLI analysis

6. **Evidence**: Capture logs/screenshots of all above steps

**Stop progression if any step fails.**

6. Diagnostic Investigation Pattern

When tests fail after removing string-based detection:

1. Create temporary diagnostic test using `SemanticModel.GetSymbolInfo()`

2. Capture actual symbol type at runtime

3. Compare against `MoqKnownSymbols` registry

4. Add missing entries to registry

5. Delete temporary test after fixing root cause

7. Update Documentation

8. Commit Changes

Use Conventional Commits format:

```

<type>[optional scope]: <description>

[optional body]

[optional footer(s)]

```

**Examples:**

9. Task List Management

Stop Conditions

**Immediately halt and escalate if:**

Context Preservation

Use appropriate analysis contexts:

Quality Standards

Example Workflow

```

1. Read instructions and identify similar component

2. Answer pre-implementation checklist

3. Register required symbols in MoqKnownSymbols

4. Write tests covering all scenarios

5. Implement analyzer/code fix using symbol-based detection

6. Run validation workflow (format → build → test → coverage → analysis)

7. Capture evidence (logs/screenshots)

8. Update documentation

9. Commit with conventional format

10. Update task list

```

Important Notes