Correctly rewrite default literals in patterns

src/Analyzers/CSharp/Analyzers/UsePatternCombinators/CSharpUsePatternCombinatorsDiagnosticAnalyzer.cs

@@ -56,7 +56,7 @@ private void AnalyzeNode(SyntaxNodeAnalysisContext context)
                 return;
 
             var semanticModel = context.SemanticModel;
-            var expressionTypeOpt = context.Compilation!.GetTypeByMetadataName("System.Linq.Expressions.Expression`1");
+            var expressionTypeOpt = semanticModel.Compilation.GetTypeByMetadataName("System.Linq.Expressions.Expression`1");
             if (expression.IsInExpressionTree(semanticModel, expressionTypeOpt, cancellationToken))
                 return;
 

src/EditorFeatures/CSharpTest/UsePatternCombinators/CSharpUsePatternCombinatorsDiagnosticAnalyzerTests.cs

@@ -50,29 +50,32 @@ private static string FromExpression(string expression)
 using System.Collections.Generic;
 class C
 {
-    bool field = {|FixAllInDocument:EXPRESSION|};
-    bool Method() => EXPRESSION;
-    bool Prop1 => EXPRESSION;
-    bool Prop2 { get } = EXPRESSION;
-    void If() { if (EXPRESSION) ; }
-    void Argument1() => Test(EXPRESSION);
-    void Argument2() => Test(() => EXPRESSION);
-    void Argument3() => Test(_ => EXPRESSION);
-    void For() { for (; EXPRESSION; ); }
-    void Local() { var local = EXPRESSION; }
-    void Conditional() { _ = EXPRESSION ? EXPRESSION : EXPRESSION; }
-    void Assignment() { _ = EXPRESSION; }
-    void Do() { do ; while (EXPRESSION); }
-    void While() { while (EXPRESSION) ; }
-    bool When() => o switch { _ when EXPRESSION => EXPRESSION };
-    bool Return() { return EXPRESSION; }
-    IEnumerable<bool> YieldReturn() { yield return EXPRESSION; }
-    Func<object, bool> SimpleLambda() => o => EXPRESSION;
-    Func<bool> ParenthesizedLambda() => () => EXPRESSION;
-    void LocalFunc() { bool LocalFunction() => EXPRESSION; }
-    int i;
-    int? nullable;
-    object o;
+    static bool field = {|FixAllInDocument:EXPRESSION|};
+    static bool Method() => EXPRESSION;
+    static bool Prop1 => EXPRESSION;
+    static bool Prop2 { get; } = EXPRESSION;
+    static void If() { if (EXPRESSION) ; }
+    static void Argument1() => Test(EXPRESSION);
+    static void Argument2() => Test(() => EXPRESSION);
+    static void Argument3() => Test(_ => EXPRESSION);
+    static void Test(bool b) {}
+    static void Test(Func<bool> b) {}
+    static void Test(Func<object, bool> b) {}
+    static void For() { for (; EXPRESSION; ); }
+    static void Local() { var local = EXPRESSION; }
+    static void Conditional() { _ = EXPRESSION ? EXPRESSION : EXPRESSION; }
+    static void Assignment() { _ = EXPRESSION; }
+    static void Do() { do ; while (EXPRESSION); }
+    static void While() { while (EXPRESSION) ; }
+    static bool When() => o switch { _ when EXPRESSION => EXPRESSION };
+    static bool Return() { return EXPRESSION; }
+    static IEnumerable<bool> YieldReturn() { yield return EXPRESSION; }
+    static Func<object, bool> SimpleLambda() => o => EXPRESSION;
+    static Func<bool> ParenthesizedLambda() => () => EXPRESSION;
+    static void LocalFunc() { bool LocalFunction() => EXPRESSION; }
+    static int i;
+    static int? nullable;
+    static object o;
 }
 ";
             return initialMarkup.Replace("EXPRESSION", expression);
@@ -85,13 +88,13 @@ class C
         [InlineData("o != null")]
         [InlineData("!(o is null)")]
         [InlineData("o is int ii || o is long jj")]
-        [InlineData("i == default || i > default(int)")]
         [Theory, Trait(Traits.Feature, Traits.Features.CodeActionsUsePatternCombinators)]
         public async Task TestMissingOnExpression(string expression)
         {
             await TestAllMissingOnExpressionAsync(expression);
         }
 
+        [InlineData("i == default || i > default(int)", "i is default(int) or > (default(int))")]
         [InlineData("!(o is C c)", "o is not C c")]
         [InlineData("o is int ii && o is long jj", "o is int ii and long jj")]
         [InlineData("!(o is C)", "o is not C")]

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

@@ -89,7 +89,7 @@ private static PatternSyntax AsPatternSyntax(AnalyzedPattern pattern)
                     Token(p.Token.LeadingTrivia, p.IsDisjunctive ? SyntaxKind.OrKeyword : SyntaxKind.AndKeyword,
                         TriviaList(p.Token.GetAllTrailingTrivia())),
                     AsPatternSyntax(p.Right).Parenthesize()),
-                Constant p => ConstantPattern(p.ExpressionSyntax.Parenthesize()),
+                Constant p => ConstantPattern(AsExpressionSyntax(p)),
                 Source p => p.PatternSyntax,
                 Type p => TypePattern(p.TypeSyntax),
                 Relational p => RelationalPattern(Token(MapToSyntaxKind(p.OperatorKind)), p.Value.Parenthesize()),
@@ -98,6 +98,22 @@ private static PatternSyntax AsPatternSyntax(AnalyzedPattern pattern)
             };
         }
 
+        private static ExpressionSyntax AsExpressionSyntax(Constant constant)
+        {
+            var expr = constant.ExpressionSyntax;
+            if (expr.IsKind(SyntaxKind.DefaultLiteralExpression))
+            {
+                // default literals are not permitted in patterns
+                var convertedType = constant.Target.SemanticModel.GetTypeInfo(expr).ConvertedType;
+                if (convertedType != null)
+                {
+                    return DefaultExpression(convertedType.GenerateTypeSyntax());
+                }
+            }
+
+            return expr.Parenthesize();
+        }
+
         private class MyCodeAction : CodeAction.DocumentChangeAction
         {
             public MyCodeAction(Func<CancellationToken, Task<Document>> createChangedDocument)