Simplify

Author: CyrusNajmabadi

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

@@ -122,7 +122,7 @@ private UnboundLambda AnalyzeAnonymousFunction(
             if (parameterSyntaxListOpt != null)
             {
                 var parameterSyntaxList = parameterSyntaxListOpt.Value;
-                var hasExplicitlyTypedParameterList = parameterSyntaxList.All(static p => p.Type != null);
+                var hasExplicitlyTypedParameterList = parameterSyntaxList.Any(static p => p.Type != null);
 
                 var typesBuilder = ArrayBuilder<TypeWithAnnotations>.GetInstance();
                 var refKindsBuilder = ArrayBuilder<RefKind>.GetInstance();
@@ -176,7 +176,11 @@ private UnboundLambda AnalyzeAnonymousFunction(
                         continue;
                     }
 
-                    var type = p.Type is not null ? BindType(p.Type, diagnostics) : default;
+                    var type = p.Type is not null
+                        ? BindType(p.Type, diagnostics)
+                        : hasExplicitlyTypedParameterList
+                            ? TypeWithAnnotations.Create(CreateErrorType())
+                            : default;
 
                     var refKind = ParameterHelpers.GetModifiers(p.Modifiers, out _, out var paramsKeyword, out _, out var scope);
                     var isParams = paramsKeyword.Kind() != SyntaxKind.None;
@@ -189,7 +193,7 @@ private UnboundLambda AnalyzeAnonymousFunction(
                         owner: null, p, ordinal: i, lastParameterIndex: n - 1, isParams: isParams, type,
                         refKind, containingSymbol: null, thisKeyword: default, paramsKeyword: paramsKeyword, firstDefault, diagnostics);
 
-                    var isLastParameter = parameterCount == parameterSyntaxListOpt.Value.Count;
+                    var isLastParameter = parameterCount == parameterSyntaxList.Count;
                     if (isLastParameter && paramsKeyword.Kind() != SyntaxKind.None && !type.IsDefault && type.IsSZArray())
                     {
                         ReportUseSiteDiagnosticForSynthesizedAttribute(Compilation,
@@ -206,7 +210,7 @@ private UnboundLambda AnalyzeAnonymousFunction(
                     defaultValueBuilder.Add(p.Default);
                 }
 
-                discardsOpt = computeDiscards(parameterSyntaxListOpt.Value, underscoresCount);
+                discardsOpt = computeDiscards(parameterSyntaxList, underscoresCount);
 
                 // Only include the types if *all* the parameters had types.  Otherwise, if there were no parameter
                 // types (or a mix of typed and untyped parameters) include no types.  Note, in the latter case we will

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

@@ -465,15 +465,15 @@ public Binder GetWithParametersBinder(LambdaSymbol lambdaSymbol, Binder binder)
             => Data.GetWithParametersBinder(lambdaSymbol, binder);
 
         /// <summary>
-        /// Whether or not the original syntax had explicit parameter list specified where all parameters had an
+        /// Whether or not the original syntax had explicit parameter list specified where any parameter had an
         /// explicit type syntax included.  Examples of where this is true are: `() => ...` `(int a) => ...` `(int a,
         /// ref int b) => ...` and so on.
         /// 
         /// Examples of where this is false is `a => ...` `(a) => ...` `(a, b) => ...` `(ref a) => ...`.
         /// 
-        /// Note 1: in the case where some parameters have types and some do not, this will return false.  That case is an
-        /// error case and an error will already be reported to the user.  In this case, we treat the parameter list as
-        /// if no parameters were provided.
+        /// Note 1: in the case where some parameters have types and some do not, this will return true.  That case is
+        /// an error case and an error will already be reported to the user.  In this case, we treat the parameter list
+        /// as if it's a mix of provided types (where there is syntax), and error types (where there is not).
         /// 
         /// Note 2: `(ref a) => ...` is legal.  So this property should not be used to determine if a parameter should
         /// have its ref/scoped/attributes checked.

src/Compilers/CSharp/Test/Syntax/Parsing/LambdaAttributeParsingTests.cs

@@ -235,7 +235,6 @@ public void LambdaAttribute_05()
             string source = "[A] (ref x) => x";
             UsingExpression(source, TestOptions.RegularPreview);
 
-
             N(SyntaxKind.ParenthesizedLambdaExpression);
             {
                 N(SyntaxKind.AttributeList);