Do not merge MA0148/MA0149 comparisons when the operand can change between evaluations

[meziantou]

Problem

The MA0148/MA0149 code fix merges adjacent comparisons into a single pattern when their operands are syntactically equivalent. Syntax equivalence does not guarantee the operand returns the same value or has no side effect:

static int count;
static int Next() => ++count;
public static object Run() => Next() == 0 || Next() == 2;

was fixed as Next() is 0 or 2. The original calls Next() twice (returns true), the fixed code calls it once (returns false). The same issue applied to != / && merged into is not (… or …).

Fix

The comparisons are merged only when the operand is stable, i.e. evaluating it again has no side effect and returns the same value:

• constants, locals, parameters, this
• non-volatile fields, static or on a stable instance
• built-in conversions (no user-defined operator) of a stable operand

Other operands (method calls, properties, indexers, …) are still converted to patterns, but kept as separate comparisons: Next() is 0 || Next() is 2, Next() is not 0 && Next() is not 2.

Notes for reviewers

• Behavior change: x.Length == 0 || x.Length == 1 is no longer merged into x.Length is 0 or 1, as a property getter can execute any code.
• Non-volatile fields are still merged, consistent with UseHasFlagMethodCommon.AreEquivalentOperands.
• docs/Rules/MA0148.md and MA0149.md document when the fix merges comparisons.

Tests

Added tests for method calls (==/|| and !=/&&), a property, and a volatile field (not merged), and a static field (merged). The 4 "do not merge" tests fail without the fix. The UsePatternMatchingForEqualityComparisonsAnalyzer* tests (37) pass on Roslyn 4.8, 4.14, 5.0, 5.6 and 5.9.