Implement lambda params with modifiers without type name

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

@@ -167,8 +167,8 @@ private UnboundLambda AnalyzeAnonymousFunction(
 
                     var typeSyntax = p.Type;
                     TypeWithAnnotations type = default;
-                    var refKind = RefKind.None;
-                    var scope = ScopedKind.None;
+
+                    var refKind = ParameterHelpers.GetModifiers(p.Modifiers, out _, out var paramsKeyword, out _, out var scope);
 
                     if (typeSyntax == null)
                     {
@@ -177,21 +177,21 @@ private UnboundLambda AnalyzeAnonymousFunction(
                     else
                     {
                         type = BindType(typeSyntax, diagnostics);
-                        ParameterHelpers.CheckParameterModifiers(p, diagnostics, parsingFunctionPointerParams: false,
-                            parsingLambdaParams: !isAnonymousMethod,
-                            parsingAnonymousMethodParams: isAnonymousMethod);
-                        refKind = ParameterHelpers.GetModifiers(p.Modifiers, out _, out var paramsKeyword, out _, out scope);
+                    }
 
-                        var isLastParameter = parameterCount == parameterSyntaxList.Value.Count;
-                        if (isLastParameter && paramsKeyword.Kind() != SyntaxKind.None)
-                        {
-                            hasParamsArray = true;
+                    ParameterHelpers.CheckParameterModifiers(p, diagnostics, parsingFunctionPointerParams: false,
+                        parsingLambdaParams: !isAnonymousMethod,
+                        parsingAnonymousMethodParams: isAnonymousMethod);
 
-                            ReportUseSiteDiagnosticForSynthesizedAttribute(Compilation,
-                                WellKnownMember.System_ParamArrayAttribute__ctor,
-                                diagnostics,
-                                paramsKeyword.GetLocation());
-                        }
+                    var isLastParameter = parameterCount == parameterSyntaxList.Value.Count;
+                    if (isLastParameter && paramsKeyword.Kind() != SyntaxKind.None)
+                    {
+                        hasParamsArray = true;
+
+                        ReportUseSiteDiagnosticForSynthesizedAttribute(Compilation,
+                            WellKnownMember.System_ParamArrayAttribute__ctor,
+                            diagnostics,
+                            paramsKeyword.GetLocation());
                     }
 
                     namesBuilder.Add(p.Identifier.ValueText);
@@ -352,14 +352,13 @@ private UnboundLambda BindAnonymousFunction(AnonymousFunctionExpressionSyntax sy
 
             var lambda = AnalyzeAnonymousFunction(syntax, diagnostics);
             var data = lambda.Data;
-            if (data.HasExplicitlyTypedParameterList)
+
+            int firstDefault = -1;
+            for (int i = 0; i < lambda.ParameterCount; i++)
             {
-                int firstDefault = -1;
-                for (int i = 0; i < lambda.ParameterCount; i++)
+                var paramSyntax = lambda.ParameterSyntax(i);
+                if (paramSyntax is not null)
                 {
-                    // paramSyntax should not be null here; we should always be operating on an anonymous function which will have parameter information
-                    var paramSyntax = lambda.ParameterSyntax(i);
-                    Debug.Assert(paramSyntax is { });
                     if (paramSyntax.Default != null && firstDefault == -1)
                     {
                         firstDefault = i;
@@ -370,7 +369,7 @@ private UnboundLambda BindAnonymousFunction(AnonymousFunctionExpressionSyntax sy
 
                     // UNDONE: Where do we report improper use of pointer types?
                     ParameterHelpers.ReportParameterErrors(owner: null, paramSyntax, ordinal: i, lastParameterIndex: lambda.ParameterCount - 1, isParams: isParams, lambda.ParameterTypeWithAnnotations(i),
-                         lambda.RefKind(i), lambda.DeclaredScope(i), containingSymbol: null, thisKeyword: default, paramsKeyword: paramsKeyword, firstDefault, diagnostics);
+                        lambda.RefKind(i), lambda.DeclaredScope(i), containingSymbol: null, thisKeyword: default, paramsKeyword: paramsKeyword, firstDefault, diagnostics);
                 }
             }
 

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

@@ -2136,26 +2136,38 @@ internal void GenerateAnonymousFunctionConversionError(BindingDiagnosticBag diag
 
             if (reason == LambdaConversionResult.MismatchedParameterType)
             {
-                // Cannot convert {0} to type '{1}' because the parameter types do not match the delegate parameter types
-                Error(diagnostics, ErrorCode.ERR_CantConvAnonMethParams, syntax, id, targetType);
+                bool hasTypeMismatch = false;
+
                 Debug.Assert(anonymousFunction.ParameterCount == delegateParameters.Length);
                 for (int i = 0; i < anonymousFunction.ParameterCount; ++i)
                 {
-                    var lambdaParameterType = anonymousFunction.ParameterType(i);
-                    if (lambdaParameterType.IsErrorType())
+                    TypeSymbol? lambdaParameterType = null;
+                    if (anonymousFunction.HasExplicitlyTypedParameterList)
                     {
-                        continue;
+                        lambdaParameterType = anonymousFunction.ParameterType(i);
+                        if (lambdaParameterType.IsErrorType())
+                        {
+                            continue;
+                        }
                     }
 
                     var lambdaParameterLocation = anonymousFunction.ParameterLocation(i);
                     var lambdaRefKind = anonymousFunction.RefKind(i);
                     var delegateParameterType = delegateParameters[i].Type;
                     var delegateRefKind = delegateParameters[i].RefKind;
 
-                    if (!lambdaParameterType.Equals(delegateParameterType, TypeCompareKind.AllIgnoreOptions))
+                    if (lambdaParameterType is not null && !lambdaParameterType.Equals(delegateParameterType, TypeCompareKind.AllIgnoreOptions))
                     {
                         SymbolDistinguisher distinguisher = new SymbolDistinguisher(this.Compilation, lambdaParameterType, delegateParameterType);
 
+                        // Report the error beforehand to preserve previous behavior
+                        if (!hasTypeMismatch)
+                        {
+                            hasTypeMismatch = true;
+                            // Cannot convert {0} to type '{1}' because the parameter types do not match the delegate parameter types
+                            Error(diagnostics, ErrorCode.ERR_CantConvAnonMethParams, syntax, id, targetType);
+                        }
+
                         // Parameter {0} is declared as type '{1}{2}' but should be '{3}{4}'
                         Error(diagnostics, ErrorCode.ERR_BadParamType, lambdaParameterLocation,
                             i + 1, lambdaRefKind.ToParameterPrefix(), distinguisher.First, delegateRefKind.ToParameterPrefix(), distinguisher.Second);

src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs

@@ -1453,31 +1453,27 @@ private static LambdaConversionResult IsAnonymousFunctionCompatibleWithDelegate(
                     return LambdaConversionResult.BadParameterCount;
                 }
 
-                // SPEC: If F has an explicitly typed parameter list, each parameter in D has the same type 
-                // SPEC: and modifiers as the corresponding parameter in F.
-                // SPEC: If F has an implicitly typed parameter list, D has no ref or out parameters.
+                // SPEC: If F has an explicitly typed or parenthesized implicitly type parameter list,
+                // SPEC: each parameter in D has the same type and modifiers as the corresponding parameter in F.
+                // SPEC: If F has an unparenthesized implicitly typed parameter list, D has no ref or out parameters.
 
-                if (anonymousFunction.HasExplicitlyTypedParameterList)
+                for (int p = 0; p < delegateParameters.Length; ++p)
                 {
-                    for (int p = 0; p < delegateParameters.Length; ++p)
+                    bool refsCompatible = OverloadResolution.AreRefsCompatibleForMethodConversion(delegateParameters[p].RefKind, anonymousFunction.RefKind(p), compilation);
+                    bool typesCompatible = true;
+                    if (anonymousFunction.HasExplicitlyTypedParameterList)
                     {
-                        if (!OverloadResolution.AreRefsCompatibleForMethodConversion(delegateParameters[p].RefKind, anonymousFunction.RefKind(p), compilation) ||
-                            !delegateParameters[p].Type.Equals(anonymousFunction.ParameterType(p), TypeCompareKind.AllIgnoreOptions))
-                        {
-                            return LambdaConversionResult.MismatchedParameterType;
-                        }
+                        typesCompatible = delegateParameters[p].Type.Equals(anonymousFunction.ParameterType(p), TypeCompareKind.AllIgnoreOptions);
                     }
-                }
-                else
-                {
-                    for (int p = 0; p < delegateParameters.Length; ++p)
+
+                    if (!typesCompatible || !refsCompatible)
                     {
-                        if (delegateParameters[p].RefKind != RefKind.None)
-                        {
-                            return LambdaConversionResult.RefInImplicitlyTypedLambda;
-                        }
+                        return LambdaConversionResult.MismatchedParameterType;
                     }
+                }
 
+                if (!anonymousFunction.HasExplicitlyTypedParameterList)
+                {
                     // In C# it is not possible to make a delegate type
                     // such that one of its parameter types is a static type. But static types are 
                     // in metadata just sealed abstract types; there is nothing stopping someone in

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

@@ -1497,28 +1497,28 @@ public override bool ParameterIsDiscard(int index)
 
         public override RefKind RefKind(int index)
         {
-            Debug.Assert(0 <= index && index < _parameterTypesWithAnnotations.Length);
+            Debug.Assert(0 <= index);
             return _parameterRefKinds.IsDefault ? Microsoft.CodeAnalysis.RefKind.None : _parameterRefKinds[index];
         }
 
         public override ScopedKind DeclaredScope(int index)
         {
-            Debug.Assert(0 <= index && index < _parameterTypesWithAnnotations.Length);
+            Debug.Assert(0 <= index);
             return _parameterDeclaredScopes.IsDefault ? ScopedKind.None : _parameterDeclaredScopes[index];
         }
 
-        public override ParameterSyntax ParameterSyntax(int index)
+        public override ParameterSyntax? ParameterSyntax(int index)
         {
-
-            Debug.Assert(_parameterSyntaxList is not null && 0 <= index && index < _parameterSyntaxList.Value.Count);
-            return _parameterSyntaxList.Value[index];
+            Debug.Assert(0 <= index);
+            Debug.Assert(_parameterSyntaxList is null || index < _parameterSyntaxList.Value.Count);
+            return _parameterSyntaxList?[index];
         }
 
         public override TypeWithAnnotations ParameterTypeWithAnnotations(int index)
         {
-            Debug.Assert(this.HasExplicitlyTypedParameterList);
-            Debug.Assert(0 <= index && index < _parameterTypesWithAnnotations.Length);
-            return _parameterTypesWithAnnotations[index];
+            Debug.Assert(0 <= index);
+            Debug.Assert(_parameterTypesWithAnnotations.IsDefault || index < _parameterTypesWithAnnotations.Length);
+            return _parameterTypesWithAnnotations.IsDefault ? default : _parameterTypesWithAnnotations[index];
         }
 
         protected override UnboundLambdaState WithCachingCore(bool includeCache)

src/Compilers/CSharp/Portable/Parser/LanguageParser.cs

@@ -12862,16 +12862,15 @@ private ParameterSyntax ParseLambdaParameter()
         {
             var attributes = ParseAttributeDeclarations(inExpressionContext: false);
 
-            // Params are actually illegal in a lambda, but we'll allow it for error recovery purposes and
-            // give the "params unexpected" error at semantic analysis time.
             SyntaxListBuilder modifiers = _pool.Allocate();
             if (IsParameterModifierExcludingScoped(this.CurrentToken) || this.CurrentToken.ContextualKind == SyntaxKind.ScopedKeyword)
             {
                 ParseParameterModifiers(modifiers, isFunctionPointerParameter: false);
             }
 
-            // If we have "scoped/ref/out/in/params" always try to parse out a type.
-            var paramType = modifiers.Count != 0 || ShouldParseLambdaParameterType()
+            bool shouldParseLambdaParameterType = ShouldParseLambdaParameterType();
+
+            var paramType = shouldParseLambdaParameterType
                 ? ParseType(ParseTypeMode.Parameter)
                 : null;
 

src/Compilers/CSharp/Portable/Symbols/Source/LambdaSymbol.cs

@@ -365,8 +365,9 @@ private ImmutableArray<ParameterSymbol> MakeParameters(
                 else if (p < numDelegateParameters)
                 {
                     type = parameterTypes[p];
-                    refKind = RefKind.None;
-                    scope = ScopedKind.None;
+                    refKind = unboundLambda.RefKind(p);
+                    scope = unboundLambda.DeclaredScope(p);
+                    paramSyntax = unboundLambda.ParameterSyntax(p);
                 }
                 else
                 {

src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs

@@ -664,31 +664,34 @@ public static void ReportParameterErrors(
                 // error CS1670: params is not valid in this context
                 diagnostics.Add(ErrorCode.ERR_IllegalParams, paramsKeyword.GetLocation());
             }
-            else if (isParams && !typeWithAnnotations.IsSZArray())
+            else if (!typeWithAnnotations.IsDefault)
             {
-                // error CS0225: The params parameter must be a single dimensional array
-                diagnostics.Add(ErrorCode.ERR_ParamsMustBeArray, paramsKeyword.GetLocation());
-            }
-            else if (typeWithAnnotations.IsStatic)
-            {
-                Debug.Assert(containingSymbol is null || (containingSymbol is FunctionPointerMethodSymbol or { ContainingType: not null }));
-                // error CS0721: '{0}': static types cannot be used as parameters
-                diagnostics.Add(
-                    ErrorFacts.GetStaticClassParameterCode(containingSymbol?.ContainingType?.IsInterfaceType() ?? false),
-                    syntax.Type?.Location ?? syntax.GetLocation(),
-                    typeWithAnnotations.Type);
-            }
-            else if (firstDefault != -1 && parameterIndex > firstDefault && !isDefault && !isParams)
-            {
-                // error CS1737: Optional parameters must appear after all required parameters
-                Location loc = ((ParameterSyntax)syntax).Identifier.GetNextToken(includeZeroWidth: true).GetLocation(); //could be missing
-                diagnostics.Add(ErrorCode.ERR_DefaultValueBeforeRequiredValue, loc);
-            }
-            else if (refKind != RefKind.None &&
-                typeWithAnnotations.IsRestrictedType(ignoreSpanLikeTypes: true))
-            {
-                // CS1601: Cannot make reference to variable of type 'System.TypedReference'
-                diagnostics.Add(ErrorCode.ERR_MethodArgCantBeRefAny, syntax.Location, typeWithAnnotations.Type);
+                if (isParams && !typeWithAnnotations.IsSZArray())
+                {
+                    // error CS0225: The params parameter must be a single dimensional array
+                    diagnostics.Add(ErrorCode.ERR_ParamsMustBeArray, paramsKeyword.GetLocation());
+                }
+                else if (typeWithAnnotations.IsStatic)
+                {
+                    Debug.Assert(containingSymbol is null || (containingSymbol is FunctionPointerMethodSymbol or { ContainingType: not null }));
+                    // error CS0721: '{0}': static types cannot be used as parameters
+                    diagnostics.Add(
+                        ErrorFacts.GetStaticClassParameterCode(containingSymbol?.ContainingType?.IsInterfaceType() ?? false),
+                        syntax.Type?.Location ?? syntax.GetLocation(),
+                        typeWithAnnotations.Type);
+                }
+                else if (firstDefault != -1 && parameterIndex > firstDefault && !isDefault && !isParams)
+                {
+                    // error CS1737: Optional parameters must appear after all required parameters
+                    Location loc = ((ParameterSyntax)syntax).Identifier.GetNextToken(includeZeroWidth: true).GetLocation(); //could be missing
+                    diagnostics.Add(ErrorCode.ERR_DefaultValueBeforeRequiredValue, loc);
+                }
+                else if (refKind != RefKind.None &&
+                    typeWithAnnotations.IsRestrictedType(ignoreSpanLikeTypes: true))
+                {
+                    // CS1601: Cannot make reference to variable of type 'System.TypedReference'
+                    diagnostics.Add(ErrorCode.ERR_MethodArgCantBeRefAny, syntax.Location, typeWithAnnotations.Type);
+                }
             }
 
             if (isParams && ordinal != lastParameterIndex)
@@ -697,7 +700,7 @@ public static void ReportParameterErrors(
                 diagnostics.Add(ErrorCode.ERR_ParamsLast, syntax.GetLocation());
             }
 
-            if (declaredScope == ScopedKind.ScopedValue && !typeWithAnnotations.IsRefLikeType())
+            if (declaredScope == ScopedKind.ScopedValue && !typeWithAnnotations.IsDefault && !typeWithAnnotations.IsRefLikeType())
             {
                 diagnostics.Add(ErrorCode.ERR_ScopedRefAndRefStructOnly, syntax.Location);
             }