Merge 'features/ParamsCollections' into 'main'

docs/contributing/Compiler Test Plan.md

@@ -49,7 +49,7 @@ This document provides guidance for thinking about language interactions and tes
 - fields (required and not)
 - properties (including get/set/init accessors, required and not)
 - events (including add/remove accessors)
-- Parameter modifiers (ref, out, in, ref readonly, params)
+- Parameter modifiers: ref, out, in, ref readonly, params (for array, for non-array)
 - Attributes (including generic attributes and security attributes)
 - Generics (type arguments, variance, constraints including `class`, `struct`, `new()`, `unmanaged`, `notnull`, types and interfaces with nullability)
 - Default and constant values

src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs

@@ -4532,6 +4532,11 @@ static bool Goo(int x, object y, object z)
                 {
                     return true;
                 }
+
+                static bool Goo(long x, object y, object z)
+                {
+                    return true;
+                }
             }
             """;
 
@@ -4568,7 +4573,19 @@ class C<T>
                     {
                     }
                 }
-
+
+                int this[long x, object s, object d]
+                {
+                    get
+                    {
+                        return 0;
+                    }
+
+                    set
+                    {
+                    }
+                }
+
                 void Goo(dynamic xx)
                 {
                     var y = this[x: xx, s: "", d: (object)""];
@@ -4681,6 +4698,11 @@ static bool Goo(object y, int x, object z)
                 {
                     return true;
                 }
+
+                static bool Goo(object y, long x, object z)
+                {
+                    return true;
+                }
             }
             """;
 
@@ -5219,10 +5241,10 @@ class Program
             {
                 public static void Main(string[] args)
                 {
-                    TakesParams([|(string)|]null);
+                    TakesParams([|(Program)|]null);
                 }
 
-                private static void TakesParams({|CS0225:params|} string wrongDefined)
+                private static void TakesParams({|CS0225:params|} Program wrongDefined)
                 {
                 }
             }
@@ -5235,7 +5257,7 @@ public static void Main(string[] args)
                     TakesParams(null);
                 }
 
-                private static void TakesParams({|CS0225:params|} string wrongDefined)
+                private static void TakesParams({|CS0225:params|} Program wrongDefined)
                 {
                 }
             }
@@ -5461,13 +5483,13 @@ await VerifyCS.VerifyCodeFixAsync(
             using System;
             sealed class MarkAttribute : Attribute
             {
-                public MarkAttribute(bool otherArg, {|CS0225:params|} string wrongDefined)
+                public MarkAttribute(bool otherArg, {|CS0225:params|} object wrongDefined)
                 {
                 }
                 public int Prop { get; set; }
             }
 
-            [Mark(true, [|(string)|]null, Prop = 1)]
+            [Mark(true, [|(object)|]null, Prop = 1)]
             static class Program
             {
             }
@@ -5476,7 +5498,7 @@ static class Program
             using System;
             sealed class MarkAttribute : Attribute
             {
-                public MarkAttribute(bool otherArg, {|CS0225:params|} string wrongDefined)
+                public MarkAttribute(bool otherArg, {|CS0225:params|} object wrongDefined)
                 {
                 }
                 public int Prop { get; set; }

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

@@ -46,7 +46,6 @@ public override bool HasExplicitReturnType(out RefKind refKind, out TypeWithAnno
             public override int ParameterCount { get { return _parameters.Length; } }
             public override bool IsAsync { get { return false; } }
             public override bool IsStatic => false;
-            public override bool HasParamsArray => false;
             public override RefKind RefKind(int index) { return Microsoft.CodeAnalysis.RefKind.None; }
             public override ScopedKind DeclaredScope(int index) => ScopedKind.None;
             public override MessageID MessageID { get { return MessageID.IDS_FeatureQueryExpression; } } // TODO: what is the correct ID here?

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

@@ -310,7 +310,7 @@ private static bool RequiresRefOrOut(BindValueKind kind)
 
 #nullable enable
 
-        private BoundIndexerAccess BindIndexerDefaultArgumentsAndParamsArray(BoundIndexerAccess indexerAccess, BindValueKind valueKind, BindingDiagnosticBag diagnostics)
+        private BoundIndexerAccess BindIndexerDefaultArgumentsAndParamsCollection(BoundIndexerAccess indexerAccess, BindValueKind valueKind, BindingDiagnosticBag diagnostics)
         {
             var useSetAccessor = valueKind == BindValueKind.Assignable && !indexerAccess.Indexer.ReturnsByRef;
             var accessorForDefaultArguments = useSetAccessor
@@ -368,7 +368,7 @@ private BoundIndexerAccess BindIndexerDefaultArgumentsAndParamsArray(BoundIndexe
                         }
                     }
 
-                    BindDefaultArgumentsAndParamsArray(indexerAccess.Syntax, parameters, argumentsBuilder, refKindsBuilderOpt, namesBuilder, ref argsToParams, out defaultArguments, indexerAccess.Expanded, enableCallerInfo: true, diagnostics);
+                    BindDefaultArgumentsAndParamsCollection(indexerAccess.Syntax, parameters, argumentsBuilder, refKindsBuilderOpt, namesBuilder, ref argsToParams, out defaultArguments, indexerAccess.Expanded, enableCallerInfo: true, diagnostics);
 
                     if (namesBuilder is object)
                     {
@@ -412,7 +412,7 @@ private BoundExpression CheckValue(BoundExpression expr, BindValueKind valueKind
                     expr = BindIndexedPropertyAccess((BoundPropertyGroup)expr, mustHaveAllOptionalParameters: false, diagnostics: diagnostics);
                     if (expr is BoundIndexerAccess indexerAccess)
                     {
-                        expr = BindIndexerDefaultArgumentsAndParamsArray(indexerAccess, valueKind, diagnostics);
+                        expr = BindIndexerDefaultArgumentsAndParamsCollection(indexerAccess, valueKind, diagnostics);
                     }
                     break;
 
@@ -430,7 +430,7 @@ private BoundExpression CheckValue(BoundExpression expr, BindValueKind valueKind
                     return expr;
 
                 case BoundKind.IndexerAccess:
-                    expr = BindIndexerDefaultArgumentsAndParamsArray((BoundIndexerAccess)expr, valueKind, diagnostics);
+                    expr = BindIndexerDefaultArgumentsAndParamsCollection((BoundIndexerAccess)expr, valueKind, diagnostics);
                     break;
 
                 case BoundKind.UnconvertedObjectCreationExpression:
@@ -474,7 +474,7 @@ private BoundExpression CheckValue(BoundExpression expr, BindValueKind valueKind
             {
                 var methodGroup = (BoundMethodGroup)expr;
                 CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
-                var resolution = this.ResolveMethodGroup(methodGroup, analyzedArguments: null, isMethodGroupConversion: false, useSiteInfo: ref useSiteInfo);
+                var resolution = this.ResolveMethodGroup(methodGroup, analyzedArguments: null, useSiteInfo: ref useSiteInfo, options: OverloadResolution.Options.None);
                 diagnostics.Add(expr.Syntax, useSiteInfo);
                 Symbol otherSymbol = null;
                 bool resolvedToMethodGroup = resolution.MethodGroup != null;
@@ -4794,7 +4794,8 @@ private SignatureOnlyMethodSymbol GetInlineArrayAccessEquivalentSignatureMethod(
                 ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol(
                                                             TypeWithAnnotations.Create(elementAccess.Expression.Type),
                                                             ImmutableArray<CustomModifier>.Empty,
-                                                            isParams: false,
+                                                            isParamsArray: false,
+                                                            isParamsCollection: false,
                                                             parameterRefKind
                                                             )),
                 resultRefKind,
@@ -4833,7 +4834,8 @@ private SignatureOnlyMethodSymbol GetInlineArrayConversionEquivalentSignatureMet
                 ImmutableArray.Create<ParameterSymbol>(new SignatureOnlyParameterSymbol(
                                                             TypeWithAnnotations.Create(inlineArray.Type),
                                                             ImmutableArray<CustomModifier>.Empty,
-                                                            isParams: false,
+                                                            isParamsArray: false,
+                                                            isParamsCollection: false,
                                                             parameterRefKind
                                                             )),
                 RefKind.None,

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

@@ -484,6 +484,8 @@ internal virtual LocalSymbol? LocalInProgress
             }
         }
 
+        internal virtual NamedTypeSymbol? ParamsCollectionTypeInProgress => null;
+
         internal virtual BoundExpression? ConditionalReceiverExpression
         {
             get

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

@@ -204,7 +204,15 @@ private BoundAttribute BindAttributeCore(AttributeSyntax node, NamedTypeSymbol a
                     out var memberResolutionResult,
                     out var candidateConstructors,
                     allowProtectedConstructorsOfBaseType: true,
-                    suppressUnsupportedRequiredMembersError: false);
+                    out CompoundUseSiteInfo<AssemblySymbol> overloadResolutionUseSiteInfo);
+
+                ReportConstructorUseSiteDiagnostics(node.Location, diagnostics, suppressUnsupportedRequiredMembersError: false, in overloadResolutionUseSiteInfo);
+
+                if (memberResolutionResult.IsNotNull)
+                {
+                    this.CheckAndCoerceArguments<MethodSymbol>(memberResolutionResult, analyzedArguments.ConstructorArguments, diagnostics, receiver: null, invokedAsExtensionMethod: false);
+                }
+
                 attributeConstructor = memberResolutionResult.Member;
                 expanded = memberResolutionResult.Resolution == MemberResolutionKind.ApplicableInExpandedForm;
                 argsToParamsOpt = memberResolutionResult.Result.ArgsToParamsOpt;
@@ -221,7 +229,7 @@ private BoundAttribute BindAttributeCore(AttributeSyntax node, NamedTypeSymbol a
                 }
                 else
                 {
-                    attributeArgumentBinder.BindDefaultArgumentsAndParamsArray(
+                    attributeArgumentBinder.BindDefaultArgumentsAndParamsCollection(
                         node,
                         attributeConstructor.Parameters,
                         analyzedArguments.ConstructorArguments.Arguments,
@@ -340,7 +348,7 @@ ImmutableArray<int> makeSourceIndices()
                     return default;
                 }
 
-                Debug.Assert(arguments.Count(a => a.IsParamsArray) == (boundAttribute.ConstructorExpanded ? 1 : 0));
+                Debug.Assert(arguments.Count(a => a.IsParamsArrayOrCollection) == (boundAttribute.ConstructorExpanded ? 1 : 0));
 
                 // make source indices if we have anything that doesn't map 1:1 from arguments to parameters:
                 // 1. implicit default arguments
@@ -372,10 +380,12 @@ ImmutableArray<int> makeSourceIndices()
                 constructorArgumentSourceIndices.Count = lengthAfterRewriting;
                 for (int argIndex = 0; argIndex < lengthAfterRewriting; argIndex++)
                 {
+                    Debug.Assert(!arguments[argIndex].IsParamsArrayOrCollection || arguments[argIndex] is BoundArrayCreation);
+
                     int paramIndex = argsToParamsOpt.IsDefault ? argIndex : argsToParamsOpt[argIndex];
                     constructorArgumentSourceIndices[paramIndex] =
                         defaultArguments[argIndex] ||
-                            (arguments[argIndex].IsParamsArray && arguments[argIndex] is BoundArrayCreation { Bounds: [BoundLiteral { ConstantValueOpt.Value: 0 }] }) ?
+                            (arguments[argIndex].IsParamsArrayOrCollection && arguments[argIndex] is BoundArrayCreation { Bounds: [BoundLiteral { ConstantValueOpt.Value: 0 }] }) ?
                         -1 : argIndex;
                 }
                 return constructorArgumentSourceIndices.ToImmutableAndFree();
@@ -901,7 +911,7 @@ private TypedConstant VisitConversion(BoundConversion node, BindingDiagnosticBag
                 var operandType = operand.Type;
 
                 if (node.Conversion.IsCollectionExpression
-                    && node.Conversion.GetCollectionExpressionTypeKind(out _) == CollectionExpressionTypeKind.Array)
+                    && node.Conversion.GetCollectionExpressionTypeKind(out _, out _, out _) == CollectionExpressionTypeKind.Array)
                 {
                     Debug.Assert(type.IsSZArray());
                     return VisitArrayCollectionExpression(type, (BoundCollectionExpression)operand, diagnostics, ref attrHasErrors, curArgumentHasErrors);

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

@@ -344,9 +344,10 @@ private bool GetGetAwaiterMethod(BoundExpression expression, SyntaxNode node, Bi
                 return false;
             }
 
-            var getAwaiterMethod = ((BoundCall)getAwaiterCall).Method;
+            var call = (BoundCall)getAwaiterCall;
+            var getAwaiterMethod = call.Method;
             if (getAwaiterMethod is ErrorMethodSymbol ||
-                HasOptionalOrVariableParameters(getAwaiterMethod) || // We might have been able to resolve a GetAwaiter overload with optional parameters, so check for that here
+                call.Expanded || HasOptionalParameters(getAwaiterMethod) || // We might have been able to resolve a GetAwaiter overload with optional parameters, so check for that here
                 getAwaiterMethod.ReturnsVoid) // If GetAwaiter returns void, don't bother checking that it returns an Awaiter.
             {
                 Error(diagnostics, ErrorCode.ERR_BadAwaitArg, node, expression.Type);
@@ -451,7 +452,8 @@ private bool GetGetResultMethod(BoundExpression awaiterExpression, SyntaxNode no
                 return false;
             }
 
-            getResultMethod = ((BoundCall)getAwaiterGetResultCall).Method;
+            var call = (BoundCall)getAwaiterGetResultCall;
+            getResultMethod = call.Method;
             if (getResultMethod.IsExtensionMethod)
             {
                 Error(diagnostics, ErrorCode.ERR_NoSuchMember, node, awaiterType, WellKnownMemberNames.GetResult);
@@ -460,7 +462,7 @@ private bool GetGetResultMethod(BoundExpression awaiterExpression, SyntaxNode no
                 return false;
             }
 
-            if (HasOptionalOrVariableParameters(getResultMethod) || getResultMethod.IsConditional)
+            if (call.Expanded || HasOptionalParameters(getResultMethod) || getResultMethod.IsConditional)
             {
                 Error(diagnostics, ErrorCode.ERR_BadAwaiterPattern, node, awaiterType, awaitedExpressionType);
                 getResultMethod = null;
@@ -472,14 +474,14 @@ private bool GetGetResultMethod(BoundExpression awaiterExpression, SyntaxNode no
             return true;
         }
 
-        private static bool HasOptionalOrVariableParameters(MethodSymbol method)
+        private static bool HasOptionalParameters(MethodSymbol method)
         {
             RoslynDebug.Assert(method != null);
 
             if (method.ParameterCount != 0)
             {
                 var parameter = method.Parameters[method.ParameterCount - 1];
-                return parameter.IsOptional || parameter.IsParams;
+                return parameter.IsOptional;
             }
 
             return false;