Add some comments

src/Features/CSharp/Portable/UsePatternCombinators/AnalyzedPattern.cs

@@ -92,6 +92,13 @@ private Binary(AnalyzedPattern leftPattern, AnalyzedPattern rightPattern, bool i
                 if (!SyntaxFactory.AreEquivalent(target, rightPattern.TargetExpression))
                     return null;
 
+                // We factor out not-patterns in a conjunction.
+                // For instance: `not 1 and not 2` is simplified as `not (1 or 2)`.
+
+                // Note that we don't do the same for disjunction, because the result would not be the same.
+                // For instance: `not 1 or not 2` cannot be rewritten as `not (1 and 2)`.
+                // The latter could be always true while that is not the case in the original form.
+
                 return !isDisjunctive && (leftPattern, rightPattern) is (Not left, Not right)
                     ? Not.Create(new Binary(left.Pattern, right.Pattern, isDisjunctive: true, token, target))
                     : new Binary(leftPattern, rightPattern, isDisjunctive, token, target);
@@ -122,7 +129,7 @@ private static BinaryOperatorKind Negate(BinaryOperatorKind kind)
                 => pattern switch
                 {
                     null => null,
-                    Not p => p.Pattern,
+                    Not p => p.Pattern, // double negative
                     Relational p => new Relational(Negate(p.OperatorKind), p.Value, p.TargetExpression),
                     _ => new Not(pattern, pattern.TargetExpression)
                 };

src/Features/CSharp/Portable/UsePatternCombinators/CSharpUsePatternCombinatorsAnalyzer.cs

@@ -101,6 +101,9 @@ private static ConstantResult DetermineConstant(IBinaryOperation op)
             return DetermineConstant(op) switch
             {
                 ConstantResult.Left when op.LeftOperand.Syntax is ExpressionSyntax left
+                    // We need to flip the operator if the constant is on the left-hand-side.
+                    // This is because relational patterns only come in the prefix form.
+                    // For instance: `123 > x` would be rewritten as `x is < 123`.
                     => new Relational(Flip(op.OperatorKind), left, GetTargetExpression(op.RightOperand)),
                 ConstantResult.Right when op.RightOperand.Syntax is ExpressionSyntax right
                     => new Relational(op.OperatorKind, right, GetTargetExpression(op.LeftOperand)),
@@ -138,8 +141,8 @@ private static bool IsRelationalOperator(BinaryOperatorKind operatorKind)
         /// Changes the direction the operator is pointing at.
         /// </summary>
         /// <remarks>
-        /// Relational patterns only come in prefix form so we'll have to
-        /// flip the operator if the original comparison has an LHS constant.
+        /// Relational patterns only come in the prefix form so we'll have to
+        /// flip the operator if the constant happens to be on the left-hand-side.
         /// </remarks>
         public static BinaryOperatorKind Flip(BinaryOperatorKind operatorKind)
         {

src/Features/CSharp/Portable/UsePatternCombinators/CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs

@@ -83,9 +83,11 @@ private void AnalyzeNode(SyntaxNodeAnalysisContext context)
             if (pattern is null)
                 return;
 
+            // Avoid rewriting trivial patterns, such as a single relational or a constant pattern.
             if (IsTrivial(pattern))
                 return;
 
+            // C# 9.0 does not support pattern variables under `not` and `or` combinators.
             if (HasIllegalPatternVariables(pattern))
                 return;