Implement lambda discard parameters

src/Compilers/CSharp/Portable/Binder/Binder.QueryUnboundLambdaState.cs

@@ -27,6 +27,8 @@ public QueryUnboundLambdaState(Binder binder, RangeVariableMap rangeVariableMap,
             }
 
             public override string ParameterName(int index) { return _parameters[index].Name; }
+            public override bool ParameterIsDiscard(int index) { return false; }
+            public override bool HasNames { get { return true; } }
             public override bool HasSignature { get { return true; } }
             public override bool HasExplicitlyTypedParameterList { get { return false; } }
             public override int ParameterCount { get { return _parameters.Length; } }

src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs

@@ -1424,7 +1424,7 @@ private BoundExpression BindIdentifier(
         /// </summary>
         private static bool FallBackOnDiscard(IdentifierNameSyntax node, DiagnosticBag diagnostics)
         {
-            if (node.Identifier.ContextualKind() != SyntaxKind.UnderscoreToken)
+            if (!node.Identifier.IsUnderscoreToken())
             {
                 return false;
             }
@@ -1441,7 +1441,7 @@ private static bool FallBackOnDiscard(IdentifierNameSyntax node, DiagnosticBag d
 
         private static bool IsOutVarDiscardIdentifier(SimpleNameSyntax node)
         {
-            Debug.Assert(node.Identifier.ContextualKind() == SyntaxKind.UnderscoreToken);
+            Debug.Assert(node.Identifier.IsUnderscoreToken());
 
             CSharpSyntaxNode parent = node.Parent;
             return (parent?.Kind() == SyntaxKind.Argument &&

src/Compilers/CSharp/Portable/Binder/Binder_Lambda.cs

@@ -31,7 +31,7 @@ internal partial class Binder
         // If we have no modifiers then the modifiers array is null; if we have any modifiers
         // then the modifiers array is non-null and not empty.
 
-        private (ImmutableArray<RefKind>, ImmutableArray<TypeWithAnnotations>, ImmutableArray<string>, bool) AnalyzeAnonymousFunction(
+        private UnboundLambda AnalyzeAnonymousFunction(
             CSharpSyntaxNode syntax, DiagnosticBag diagnostics)
         {
             Debug.Assert(syntax != null);
@@ -43,6 +43,7 @@ internal partial class Binder
             bool isAsync = false;
 
             var namesBuilder = ArrayBuilder<string>.GetInstance();
+            ImmutableArray<bool> discardsOpt = default;
             SeparatedSyntaxList<ParameterSyntax>? parameterSyntaxList = null;
             bool hasSignature;
 
@@ -94,8 +95,14 @@ internal partial class Binder
                 // However, we still want to give errors on every bad type in the list, even if one
                 // is missing.
 
+                int underscoresCount = 0;
                 foreach (var p in parameterSyntaxList.Value)
                 {
+                    if (p.Identifier.IsUnderscoreToken())
+                    {
+                        underscoresCount++;
+                    }
+
                     foreach (var attributeList in p.AttributeLists)
                     {
                         Error(diagnostics, ErrorCode.ERR_AttributesNotAllowed, attributeList);
@@ -161,6 +168,8 @@ internal partial class Binder
                     refKindsBuilder.Add(refKind);
                 }
 
+                discardsOpt = computeDiscards(parameterSyntaxList.Value, underscoresCount);
+
                 if (hasExplicitlyTypedParameterList)
                 {
                     types = typesBuilder.ToImmutable();
@@ -182,7 +191,24 @@ internal partial class Binder
 
             namesBuilder.Free();
 
-            return (refKinds, types, names, isAsync);
+            return new UnboundLambda(syntax, this, refKinds, types, names, discardsOpt, isAsync);
+
+            static ImmutableArray<bool> computeDiscards(SeparatedSyntaxList<ParameterSyntax> parameters, int underscoresCount)
+            {
+                if (underscoresCount <= 1)
+                {
+                    return default;
+                }
+
+                // When there are two or more underscores, they are discards
+                var discardsBuilder = ArrayBuilder<bool>.GetInstance(parameters.Count);
+                foreach (var p in parameters)
+                {
+                    discardsBuilder.Add(p.Identifier.IsUnderscoreToken());
+                }
+
+                return discardsBuilder.ToImmutableAndFree();
+            }
         }
 
         private void CheckParenthesizedLambdaParameters(
@@ -216,25 +242,27 @@ private UnboundLambda BindAnonymousFunction(CSharpSyntaxNode syntax, DiagnosticB
             Debug.Assert(syntax != null);
             Debug.Assert(syntax.IsAnonymousFunction());
 
-            var (refKinds, types, names, isAsync) = AnalyzeAnonymousFunction(syntax, diagnostics);
-            if (!types.IsDefault)
+            var lambda = AnalyzeAnonymousFunction(syntax, diagnostics);
+            var data = lambda.Data;
+            if (data.HasExplicitlyTypedParameterList)
             {
-                foreach (var type in types)
+                for (int i = 0; i < lambda.ParameterCount; i++)
                 {
                     // UNDONE: Where do we report improper use of pointer types?
+                    var type = lambda.Data.ParameterTypeWithAnnotations(i);
                     if (type.HasType && type.IsStatic)
                     {
                         Error(diagnostics, ErrorCode.ERR_ParameterIsStaticClass, syntax, type.Type);
                     }
                 }
             }
 
-            var lambda = new UnboundLambda(syntax, this, refKinds, types, names, isAsync);
-            if (!names.IsDefault)
+            if (data.HasNames)
             {
                 var binder = new LocalScopeBinder(this);
                 bool allowShadowingNames = binder.Compilation.IsFeatureEnabled(MessageID.IDS_FeatureNameShadowingInNestedFunctions);
                 var pNames = PooledHashSet<string>.GetInstance();
+                bool seenDiscard = false;
 
                 for (int i = 0; i < lambda.ParameterCount; i++)
                 {
@@ -245,6 +273,21 @@ private UnboundLambda BindAnonymousFunction(CSharpSyntaxNode syntax, DiagnosticB
                         continue;
                     }
 
+                    if (lambda.ParameterIsDiscard(i))
+                    {
+                        if (seenDiscard)
+                        {
+                            // We only report the diagnostic on the second and subsequent underscores
+                            MessageID.IDS_FeatureLambdaDiscardParameters.CheckFeatureAvailability(
+                                diagnostics,
+                                binder.Compilation,
+                                lambda.ParameterLocation(i));
+                        }
+
+                        seenDiscard = true;
+                        continue;
+                    }
+
                     if (!pNames.Add(name))
                     {
                         // The parameter name '{0}' is a duplicate

src/Compilers/CSharp/Portable/Binder/Binder_Operators.cs

@@ -2752,7 +2752,7 @@ private BoundExpression BindIsOperator(BinaryExpressionSyntax node, DiagnosticBa
             TypeWithAnnotations targetTypeWithAnnotations = BindType(node.Right, isTypeDiagnostics, out alias);
             TypeSymbol targetType = targetTypeWithAnnotations.Type;
 
-            bool wasUnderscore = node.Right is IdentifierNameSyntax name && name.Identifier.ContextualKind() == SyntaxKind.UnderscoreToken;
+            bool wasUnderscore = node.Right is IdentifierNameSyntax name && name.Identifier.IsUnderscoreToken();
             if (!wasUnderscore && targetType?.IsErrorType() == true && isTypeDiagnostics.HasAnyResolvedErrors() &&
                 ((CSharpParseOptions)node.SyntaxTree.Options).IsFeatureEnabled(MessageID.IDS_FeaturePatternMatching))
             {

src/Compilers/CSharp/Portable/Binder/SwitchBinder_Patterns.cs

@@ -288,7 +288,7 @@ private BoundSwitchLabel BindSwitchSectionLabel(
             void reportIfConstantNamedUnderscore(BoundPattern pattern, ExpressionSyntax expression)
             {
                 if (!pattern.HasErrors &&
-                    expression is IdentifierNameSyntax name && name.Identifier.ContextualKind() == SyntaxKind.UnderscoreToken)
+                    expression is IdentifierNameSyntax name && name.Identifier.IsUnderscoreToken())
                 {
                     diagnostics.Add(ErrorCode.WRN_CaseConstantNamedUnderscore, expression.Location);
                 }

src/Compilers/CSharp/Portable/Binder/WithLambdaParametersBinder.cs

@@ -25,22 +25,25 @@ public WithLambdaParametersBinder(LambdaSymbol lambdaSymbol, Binder enclosing)
             var parameters = lambdaSymbol.Parameters;
             if (!parameters.IsDefaultOrEmpty)
             {
-                RecordDefinitions(parameters);
+                recordDefinitions(parameters);
                 foreach (var parameter in lambdaSymbol.Parameters)
                 {
-                    this.parameterMap.Add(parameter.Name, parameter);
+                    if (!parameter.IsDiscard)
+                    {
+                        this.parameterMap.Add(parameter.Name, parameter);
+                    }
                 }
             }
-        }
 
-        private void RecordDefinitions(ImmutableArray<ParameterSymbol> definitions)
-        {
-            var declarationMap = _definitionMap ?? (_definitionMap = new SmallDictionary<string, ParameterSymbol>());
-            foreach (var s in definitions)
+            void recordDefinitions(ImmutableArray<ParameterSymbol> definitions)
             {
-                if (!declarationMap.ContainsKey(s.Name))
+                var declarationMap = _definitionMap ??= new SmallDictionary<string, ParameterSymbol>();
+                foreach (var s in definitions)
                 {
-                    declarationMap.Add(s.Name, s);
+                    if (!s.IsDiscard && !declarationMap.ContainsKey(s.Name))
+                    {
+                        declarationMap.Add(s.Name, s);
+                    }
                 }
             }
         }

src/Compilers/CSharp/Portable/BoundTree/UnboundLambda.cs

@@ -327,13 +327,14 @@ public UnboundLambda(
             ImmutableArray<RefKind> refKinds,
             ImmutableArray<TypeWithAnnotations> types,
             ImmutableArray<string> names,
+            ImmutableArray<bool> discardsOpt,
             bool isAsync,
             bool hasErrors = false)
             : base(BoundKind.UnboundLambda, syntax, null, hasErrors || !types.IsDefault && types.Any(t => t.Type?.Kind == SymbolKind.ErrorType))
         {
             Debug.Assert(binder != null);
             Debug.Assert(syntax.IsAnonymousFunction());
-            this.Data = new PlainUnboundLambdaState(this, binder, names, types, refKinds, isAsync);
+            this.Data = new PlainUnboundLambdaState(this, binder, names, discardsOpt, types, refKinds, isAsync);
         }
 
         private UnboundLambda(UnboundLambda other, Binder binder, NullableWalker.VariableState nullableState) :
@@ -376,6 +377,7 @@ public TypeWithAnnotations InferReturnType(ConversionsBase conversions, NamedTyp
         public TypeSymbol ParameterType(int index) { return ParameterTypeWithAnnotations(index).Type; }
         public Location ParameterLocation(int index) { return Data.ParameterLocation(index); }
         public string ParameterName(int index) { return Data.ParameterName(index); }
+        public bool ParameterIsDiscard(int index) { return Data.ParameterIsDiscard(index); }
     }
 
     internal abstract class UnboundLambdaState
@@ -415,13 +417,15 @@ public void SetUnboundLambda(UnboundLambda unbound)
 
         public abstract MessageID MessageID { get; }
         public abstract string ParameterName(int index);
+        public abstract bool ParameterIsDiscard(int index);
         public abstract bool HasSignature { get; }
         public abstract bool HasExplicitlyTypedParameterList { get; }
         public abstract int ParameterCount { get; }
         public abstract bool IsAsync { get; }
+        public abstract bool HasNames { get; }
+
         public abstract Location ParameterLocation(int index);
         public abstract TypeWithAnnotations ParameterTypeWithAnnotations(int index);
-        //public abstract SyntaxToken ParameterIdentifier(int index);
         public abstract RefKind RefKind(int index);
         protected abstract BoundBlock BindLambdaBody(LambdaSymbol lambdaSymbol, Binder lambdaBodyBinder, DiagnosticBag diagnostics);
 
@@ -1078,6 +1082,7 @@ private static int CanonicallyCompareDiagnostics(Diagnostic x, Diagnostic y)
     internal class PlainUnboundLambdaState : UnboundLambdaState
     {
         private readonly ImmutableArray<string> _parameterNames;
+        private readonly ImmutableArray<bool> _parameterIsDiscardOpt;
         private readonly ImmutableArray<TypeWithAnnotations> _parameterTypesWithAnnotations;
         private readonly ImmutableArray<RefKind> _parameterRefKinds;
         private readonly bool _isAsync;
@@ -1086,17 +1091,21 @@ internal PlainUnboundLambdaState(
             UnboundLambda unboundLambda,
             Binder binder,
             ImmutableArray<string> parameterNames,
+            ImmutableArray<bool> parameterIsDiscardOpt,
             ImmutableArray<TypeWithAnnotations> parameterTypesWithAnnotations,
             ImmutableArray<RefKind> parameterRefKinds,
             bool isAsync)
             : base(binder, unboundLambda)
         {
             _parameterNames = parameterNames;
+            _parameterIsDiscardOpt = parameterIsDiscardOpt;
             _parameterTypesWithAnnotations = parameterTypesWithAnnotations;
             _parameterRefKinds = parameterRefKinds;
             _isAsync = isAsync;
         }
 
+        public override bool HasNames { get { return !_parameterNames.IsDefault; } }
+
         public override bool HasSignature { get { return !_parameterNames.IsDefault; } }
 
         public override bool HasExplicitlyTypedParameterList { get { return !_parameterTypesWithAnnotations.IsDefault; } }
@@ -1139,6 +1148,11 @@ public override string ParameterName(int index)
             return _parameterNames[index];
         }
 
+        public override bool ParameterIsDiscard(int index)
+        {
+            return _parameterIsDiscardOpt.IsDefault ? false : _parameterIsDiscardOpt[index];
+        }
+
         public override RefKind RefKind(int index)
         {
             Debug.Assert(0 <= index && index < _parameterTypesWithAnnotations.Length);

src/Compilers/CSharp/Portable/CSharpExtensions.cs

@@ -39,6 +39,11 @@ internal static SyntaxKind ContextualKind(this SyntaxToken token)
             return (object)token.Language == (object)LanguageNames.CSharp ? (SyntaxKind)token.RawContextualKind : SyntaxKind.None;
         }
 
+        internal static bool IsUnderscoreToken(this SyntaxToken identifier)
+        {
+            return identifier.ContextualKind() == SyntaxKind.UnderscoreToken;
+        }
+
         /// <summary>
         /// Returns the index of the first node of a specified kind in the node list.
         /// </summary>

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -5744,6 +5744,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="IDS_FeatureNameShadowingInNestedFunctions" xml:space="preserve">
     <value>name shadowing in nested functions</value>
   </data>
+  <data name="IDS_FeatureLambdaDiscardParameters" xml:space="preserve">
+    <value>lambda discard parameters</value>
+  </data>
   <data name="ERR_BadDynamicAwaitForEach" xml:space="preserve">
     <value>Cannot use a collection of dynamic type in an asynchronous foreach</value>
   </data>

src/Compilers/CSharp/Portable/Errors/MessageID.cs

@@ -184,6 +184,7 @@ internal enum MessageID
         IDS_FeatureNestedStackalloc = MessageBase + 12762,
         IDS_FeatureSwitchExpression = MessageBase + 12763,
         IDS_FeatureAsyncUsing = MessageBase + 12764,
+        IDS_FeatureLambdaDiscardParameters = MessageBase + 12765,
     }
 
     // Message IDs may refer to strings that need to be localized.
@@ -282,7 +283,6 @@ private static CSDiagnosticInfo GetDisabledFeatureDiagnosticInfo(MessageID featu
                 : new CSDiagnosticInfo(availableVersion.GetErrorCode(), feature.Localize(), new CSharpRequiredLanguageVersion(requiredVersion));
         }
 
-
         internal static LanguageVersion RequiredVersion(this MessageID feature)
         {
             Debug.Assert(RequiredFeature(feature) == null);
@@ -291,6 +291,10 @@ internal static LanguageVersion RequiredVersion(this MessageID feature)
             // Checks are in the LanguageParser unless otherwise noted.
             switch (feature)
             {
+                // Preview features.
+                case MessageID.IDS_FeatureLambdaDiscardParameters: // semantic check
+                    return LanguageVersion.Preview;
+
                 // C# 8.0 features.
                 case MessageID.IDS_FeatureAltInterpolatedVerbatimStrings:
                 case MessageID.IDS_FeatureCoalesceAssignmentExpression:

src/Compilers/CSharp/Portable/Symbols/Metadata/PE/PEParameterSymbol.cs

@@ -409,6 +409,14 @@ public override int Ordinal
             }
         }
 
+        public override bool IsDiscard
+        {
+            get
+            {
+                return false;
+            }
+        }
+
         // might be Nil
         internal ParameterHandle Handle
         {

src/Compilers/CSharp/Portable/Symbols/ParameterSymbol.cs

@@ -60,6 +60,11 @@ protected override sealed Symbol OriginalSymbolDefinition
         /// </summary>
         public abstract RefKind RefKind { get; }
 
+        /// <summary>
+        /// Returns true if the parameter is a discard parameter.
+        /// </summary>
+        public abstract bool IsDiscard { get; }
+
         /// <summary>
         /// Custom modifiers associated with the ref modifier, or an empty array if there are none.
         /// </summary>

src/Compilers/CSharp/Portable/Symbols/PublicModel/ParameterSymbol.cs

@@ -54,6 +54,8 @@ IParameterSymbol IParameterSymbol.OriginalDefinition
 
         RefKind IParameterSymbol.RefKind => _underlying.RefKind;
 
+        bool IParameterSymbol.IsDiscard => _underlying.IsDiscard;
+
         bool IParameterSymbol.IsParams => _underlying.IsParams;
 
         bool IParameterSymbol.IsOptional => _underlying.IsOptional;

src/Compilers/CSharp/Portable/Symbols/SignatureOnlyParameterSymbol.cs

@@ -44,6 +44,8 @@ public SignatureOnlyParameterSymbol(
 
         public override bool IsImplicitlyDeclared { get { return true; } }
 
+        public override bool IsDiscard { get { return false; } }
+
         #region Not used by MethodSignatureComparer
 
         internal override bool IsMetadataIn { get { throw ExceptionUtilities.Unreachable; } }