Introduce a DiscardSyntaxClassifier

src/EditorFeatures/CSharpTest/Classification/SemanticClassifierTests.cs

@@ -3612,5 +3612,186 @@ void M<T>() where T : notnull { }
                 TypeParameter("T"),
                 Keyword("notnull"));
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Classification)]
+        public async Task DiscardInOutDeclaration()
+        {
+            await TestAsync(@"
+class X
+{
+    void N()
+    {
+        int.TryParse("""", out var _);
+    }
+}",
+            Method("TryParse"),
+            Static("TryParse"),
+            Keyword("var"),
+            Keyword("_"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Classification)]
+        public async Task DiscardInOutAssignment()
+        {
+            await TestAsync(@"
+class X
+{
+    void N()
+    {
+        int.TryParse("""", out _);
+    }
+}",
+            Method("TryParse"),
+            Static("TryParse"),
+            Keyword("_"));
+        }
+
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Classification)]
+        public async Task DiscardInDeconstructionAssignment()
+        {
+            await TestAsync(@"
+class X
+{
+    void N()
+    {
+        (x, _) = (0, 0);
+    }
+}",
+            Keyword("_"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Classification)]
+        public async Task DiscardInDeconstructionDeclaration()
+        {
+            await TestAsync(@"
+class X
+{
+    void N()
+    {
+        (int x, int _) = (0, 0);
+    }
+}",
+            Keyword("_"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Classification)]
+        public async Task DiscardInPatternMatch()
+        {
+            await TestAsync(@"
+class X
+{
+    bool N(object x)
+    {
+        return x is int _;
+    }
+}",
+            Parameter("x"),
+            Keyword("_"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Classification)]
+        public async Task DiscardInSwitch()
+        {
+            await TestAsync(@"
+class X
+{
+    bool N(object x)
+    {
+        switch(x)
+        {
+            case int _:
+                return true;
+            default:
+                return false;
+        }
+    }
+}",
+            Parameter("x"),
+            Keyword("_"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Classification)]
+        public async Task DiscardInSwitchPatternMatch()
+        {
+            await TestAsync(@"
+class X
+{
+    bool N(object x)
+    {
+        return x switch
+        {
+            _ => return true;
+        };
+    }
+}",
+            Parameter("x"),
+            Keyword("_"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Classification)]
+        public async Task UnusedUnderscoreParameterInLambda()
+        {
+            await TestAsync(@"
+class X
+{
+    void N()
+    {
+        System.Func<int, int> a = (int _) => 0;
+    }
+}",
+            Namespace("System"),
+            Delegate("Func"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Classification)]
+        public async Task UsedUnderscoreParameterInLambda()
+        {
+            await TestAsync(@"
+class X
+{
+    void N()
+    {
+        System.Func<int, int> a = (int _) => _;
+    }
+}",
+            Namespace("System"),
+            Delegate("Func"),
+            Parameter("_"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Classification)]
+        public async Task DiscardsInLambda()
+        {
+            await TestAsync(@"
+class X
+{
+    void N()
+    {
+        System.Func<int, int, int> a = (int _, int _) => 0;
+    }
+}",
+            Namespace("System"),
+            Delegate("Func"),
+            Keyword("_"),
+            Keyword("_"));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Classification)]
+        public async Task DiscardsInLambdaWithInferredType()
+        {
+            await TestAsync(@"
+class X
+{
+    void N()
+    {
+        System.Func<int, int, int> a = (_, _) => 0;
+    }
+}",
+            Namespace("System"),
+            Delegate("Func"),
+            Keyword("_"),
+            Keyword("_"));
+        }
     }
 }

src/Workspaces/CSharp/Portable/Classification/SyntaxClassification/CSharpSyntaxClassificationService.cs

@@ -36,7 +36,8 @@ public CSharpSyntaxClassificationService(HostLanguageServices languageServices)
                     new NameSyntaxClassifier(),
                     new OperatorOverloadSyntaxClassifier(),
                     new SyntaxTokenClassifier(),
-                    new UsingDirectiveSyntaxClassifier()
+                    new UsingDirectiveSyntaxClassifier(),
+                    new DiscardSyntaxClassifier()
                 });
         }
 

src/Workspaces/CSharp/Portable/Classification/SyntaxClassification/DiscardSyntaxClassifier.cs

@@ -0,0 +1,85 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+#nullable enable
+
+using System;
+using System.Collections.Immutable;
+using System.Threading;
+using Microsoft.CodeAnalysis.Classification;
+using Microsoft.CodeAnalysis.Classification.Classifiers;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp.Classification.Classifiers
+{
+    internal class DiscardSyntaxClassifier : AbstractSyntaxClassifier
+    {
+        public override ImmutableArray<Type> SyntaxNodeTypes { get; } = ImmutableArray.Create(
+            typeof(DiscardDesignationSyntax),
+            typeof(DiscardPatternSyntax),
+            typeof(LambdaExpressionSyntax),
+            typeof(IdentifierNameSyntax));
+
+        public override void AddClassifications(
+           Workspace workspace,
+           SyntaxNode syntax,
+           SemanticModel semanticModel,
+           ArrayBuilder<ClassifiedSpan> result,
+           CancellationToken cancellationToken)
+        {
+            if (syntax.IsKind(SyntaxKind.DiscardDesignation) || syntax.IsKind(SyntaxKind.DiscardPattern))
+            {
+                result.Add(new ClassifiedSpan(syntax.Span, ClassificationTypeNames.Keyword));
+                return;
+            }
+
+            switch (syntax)
+            {
+                case LambdaExpressionSyntax lambda:
+                    {
+                        var symbolInfo = semanticModel.GetSymbolInfo(lambda, cancellationToken);
+                        ClassifyLambdaParameter(symbolInfo, result);
+                    }
+                    break;
+
+                case IdentifierNameSyntax identifier:
+                    if (identifier.Identifier.Text == "_")
+                    {
+                        var symbolInfo = semanticModel.GetSymbolInfo(identifier, cancellationToken);
+
+                        if (symbolInfo.Symbol?.Kind == SymbolKind.Discard)
+                        {
+                            result.Add(new ClassifiedSpan(syntax.Span, ClassificationTypeNames.Keyword));
+                        }
+                    }
+                    break;
+
+                default:
+                    throw ExceptionUtilities.Unreachable;
+            };
+        }
+
+        private void ClassifyLambdaParameter(SymbolInfo symbolInfo, ArrayBuilder<ClassifiedSpan> result)
+        {
+            // classify lambda parameters of the forms 
+            // (int _, int _) => ... 
+            // or 
+            // (_, _) => ...
+            // which aren't covered by TryClassifySymbol
+
+            if (!(symbolInfo.Symbol is IMethodSymbol symbol))
+            {
+                return;
+            }
+
+            foreach (var parameter in symbol.Parameters)
+            {
+                if (parameter.IsDiscard)
+                {
+                    result.Add(new ClassifiedSpan(parameter.Locations[0].SourceSpan, ClassificationTypeNames.Keyword));
+                }
+            }
+        }
+    }
+}