Audit by Deep Research

Audit of StyleCopAnalyzers Rules for Static Anonymous Functions :contentReference[oaicite:1]{index=1}

This audit covers C# 9 static anonymous functions (static lambdas and static anonymous methods) and their impact on StyleCopAnalyzers rules.

Rules Needing Implementation Changes

SA1130 – UseLambdaSyntax

Behavior

SA1130 discourages the delegate (...) { } anonymous method syntax in favor of lambdas.
For static anonymous methods, the rule and its code fix must preserve static.

Required / implemented changes

When encountering static delegate(int x) { }, SA1130 should report a diagnostic and the code fix should produce:
```
static (int x) => { }
```

not just (int x) => { }.

The static modifier must be kept to maintain “no capture” semantics.

Tests

Action a = static delegate { }; → SA1130 reported; fix → static () => { }.
Func<int, int> f = static delegate(int x) { return x; }; → fix → static (int x) => x;.

SA1410 – RemoveDelegateParenthesisWhenPossible

Behavior

Removes unnecessary () in anonymous methods with no parameters.

Static anonymous functions

static delegate() { } should be treated like delegate() { }:
- Diagnostic: parentheses can be removed.
- Fix: static delegate { }.

Tests

Confirm SA1410 fires for static delegate() and removes the empty parameter list.

SA1008 – OpeningParenthesisMustBeSpacedCorrectly (design decision)

Context

Spacing around ( after static in lambdas: static(x) vs static (x).

Current style (per audit)

Analyzer currently treats static like an identifier: no space required before (.
So static(x) is considered correct; static (x) might be flagged depending on SA1008/SA1000 configuration.

Design point

If the project wants static (x) for readability (like if (), SA1008/SA1000 would need changes to treat static like a control-flow keyword.
Otherwise, only tests are needed to confirm existing behavior.

Tests

Add tests demonstrating whichever style is chosen:
- If no space style: static(x) is valid; static (x) is reported.
- If space style is preferred: invert expectations accordingly.

SA1101 – PrefixLocalCallsWithThis

Behavior

Flags unqualified instance member access where this. should be used.

Static anonymous functions

Static lambdas cannot capture instance members at all; such code does not compile.
The rule already checks symbol static-ness and should naturally ignore these cases.

Action

No code change expected, but add tests to confirm:
- The analyzer does not crash in static lambdas.
- It does not report spurious SA1101 diagnostics.

Rules Requiring Documentation Updates

SA1130 – UseLambdaSyntax

Update docs to explicitly say static anonymous methods are also covered:
- static delegate (...) { } should be replaced with static (...) => { }.

SA1410 – RemoveDelegateParenthesisWhenPossible

Note that the rule applies equally to static anonymous methods:
- static delegate() { } → static delegate { }.

Parameter-list formatting rules (SA1110–SA1117)

These rules already apply to anonymous methods and lambdas; docs should be explicit:

SA1110, SA1111, SA1113, SA1114, SA1115, SA1116, SA1117:
- State that they also cover anonymous function parameter lists, including static lambdas and static anonymous methods.
- For example, SA1111 (closing parenthesis on same line as the last parameter) also applies to lambdas.

SA1118 – ParameterMustNotSpanMultipleLines

Docs mention an exception that allows anonymous functions passed as arguments to span multiple lines.
Clarify explicitly that static lambdas are included in this exception.

Tests to Add or Extend

SA1130 – UseLambdaSyntax

Static anonymous methods:
- Action a = static delegate { }; → SA1130; fix to static () => { }.
- Func<int, int> f = static delegate(int x, int y) { return x + y; }; → fix to static (x, y) => x + y;.

SA1410 – RemoveDelegateParenthesis

Static delegates with no parameters:
- Func<int> f = static delegate() { return 42; }; → SA1410; fix to static delegate { return 42; };.

Spacing in static lambdas (SA1008/SA1000)

Confirm chosen style:
- If static(x) => x; is correct and static (x) => x; is not, add matching tests.
- Or vice versa, depending on final design.

SA1110–SA1117 – parameter list rules

Add static-lambda variants of existing tests:
- SA1110/SA1114:
  - Func<int, int> sum = static (int x, int y) => x + y; with line breaks that should/shouldn’t be allowed.
- SA1111:
  - Multi-line static lambda ensuring ) is aligned with last parameter.
- SA1113:
  - Static lambda parameters split across lines; comma must remain on same line as preceding parameter.
- SA1115/1116/1117:
  - Variants of single-line vs. one-parameter-per-line static lambdas to ensure correct diagnostics.

SA1118 – Static lambdas as arguments

Example:

SomeMethod(
    firstArg,
    static (int x) =>
    {
        // body
    });

The second (non-first) argument spans multiple lines but is an anonymous function, so SA1118 must not complain.

SA1101 – Static lambdas and instance access

Non-compiling sample to ensure no crashes (syntactic analysis only):

int y = 0;
Action<int> a = static (x) => { var z = x + y; };

Valid static access scenario:

static int s;
Action a = static () => { s.ToString(); }; // no SA1101

Summary

With the above implementation checks, documentation tweaks, and tests, StyleCopAnalyzers will fully handle static anonymous functions:

SA1130 and SA1410 understand and correctly transform static delegate.
Spacing and parameter-list rules apply to static lambdas as they do to regular lambdas.
SA1101 and related rules behave correctly in static contexts, with no crashes or false positives.

Review impact of static anonymous functions on existing rules #3973

Description

Metadata

Metadata

Assignees

Labels

Type

Projects

Milestone

Relationships

Development

Issue actions