Collection expressions: require Add method callable with a single argument for class and struct types that do not use [CollectionBuilder]

src/Analyzers/CSharp/Tests/UseCollectionInitializer/UseCollectionInitializerTests_CollectionExpression.cs

@@ -5270,16 +5270,6 @@ public void Add(string s) { }
             {
                 OutputKind = OutputKind.DynamicallyLinkedLibrary,
             },
-            FixedState =
-            {
-                ExpectedDiagnostics =
-                {
-                    // /0/Test0.cs(6,26): error CS1503: Argument 1: cannot convert from 'object' to 'string'
-                    DiagnosticResult.CompilerError("CS1503").WithSpan(6, 26, 6, 36).WithArguments("1", "object", "string"),
-                    // /0/Test0.cs(6,26): error CS9215: Collection expression type must have an applicable instance or extension method 'Add' that can be called with an argument of iteration type 'object'. The best overloaded method is 'MyCollection.Add(string)'.
-                    DiagnosticResult.CompilerError("CS9215").WithSpan(6, 26, 6, 36).WithArguments("object", "MyCollection.Add(string)"),
-                }
-            }
         }.RunAsync();
     }
 

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

@@ -1285,21 +1285,112 @@ static bool bindInvocationExpressionContinued(
             }
         }
 
+        internal bool HasCollectionExpressionAddMethod(SyntaxNode syntax, TypeSymbol targetType)
+        {
+            const string methodName = "Add";
+            var useSiteInfo = CompoundUseSiteInfo<AssemblySymbol>.Discarded;
+
+            var lookupResult = LookupResult.GetInstance();
+            LookupInstanceMember(lookupResult, targetType, leftIsBaseReference: false, rightName: methodName, rightArity: 0, invoked: true, ref useSiteInfo);
+            bool anyApplicable = lookupResult.IsMultiViable &&
+                lookupResult.Symbols.Any(s => s is MethodSymbol m && isApplicableAddMethod(m, expectingExtensionMethod: false));
+            lookupResult.Free();
+            if (anyApplicable)
+            {
+                return true;
+            }
+
+            var implicitReceiver = new BoundObjectOrCollectionValuePlaceholder(syntax, isNewInstance: true, targetType) { WasCompilerGenerated = true };
+            foreach (var scope in new ExtensionMethodScopes(this))
+            {
+                var methodGroup = MethodGroup.GetInstance();
+                PopulateExtensionMethodsFromSingleBinder(scope, methodGroup, syntax, implicitReceiver, rightName: methodName, typeArgumentsWithAnnotations: default, BindingDiagnosticBag.Discarded);
+                anyApplicable = methodGroup.Methods.Any(m => isApplicableAddMethod(m, expectingExtensionMethod: true));
+                methodGroup.Free();
+                if (anyApplicable)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+
+            static bool isApplicableAddMethod(MethodSymbol method, bool expectingExtensionMethod)
+            {
+                if (method.IsStatic != expectingExtensionMethod)
+                {
+                    return false;
+                }
+
+                var parameters = method.Parameters;
+                int valueIndex = expectingExtensionMethod ? 1 : 0;
+                int requiredLength = valueIndex + 1;
+                if (parameters.Length < requiredLength)
+                {
+                    return false;
+                }
+
+                // Any trailing parameters must be optional or params.
+                for (int i = requiredLength; i < parameters.Length; i++)
+                {
+                    if (parameters[i] is { IsOptional: false, IsParams: false })
+                    {
+                        return false;
+                    }
+                }
+
+                // Value parameter must be by value, in, or ref readonly.
+                if (parameters[valueIndex].RefKind is not (RefKind.None or RefKind.In or RefKind.RefReadOnlyParameter))
+                {
+                    return false;
+                }
+
+                // If the method is generic, can the type arguments be inferred from the one or two arguments?
+                var typeParameters = method.TypeParameters;
+                if (typeParameters.Length > 0)
+                {
+                    var usedParameterTypes = parameters.Slice(0, requiredLength).SelectAsArray(p => p.Type);
+                    foreach (var typeParameter in typeParameters)
+                    {
+                        if (!usedParameterTypes.Any((parameterType, typeParameter) => parameterType.ContainsTypeParameter(typeParameter), typeParameter))
+                        {
+                            // The type parameter does not appear in any of the parameter types.
+                            return false;
+                        }
+                    }
+                }
+
+                return true;
+            }
+        }
+
         /// <summary>
         /// If the element is from a collection type where elements are added with collection initializers,
         /// return the argument to the collection initializer Add method or null if the element is not a
         /// collection initializer node. Otherwise, return the element as is.
         /// </summary>
-        internal static BoundExpression? GetUnderlyingCollectionExpressionElement(BoundCollectionExpression expr, BoundExpression? element)
+        internal static BoundExpression GetUnderlyingCollectionExpressionElement(BoundCollectionExpression expr, BoundExpression element, bool throwOnErrors)
         {
             if (expr.CollectionTypeKind is CollectionExpressionTypeKind.ImplementsIEnumerable)
             {
-                return element switch
+                switch (element)
                 {
-                    BoundCollectionElementInitializer collectionInitializer => getCollectionInitializerElement(collectionInitializer),
-                    BoundDynamicCollectionElementInitializer dynamicInitializer => dynamicInitializer.Arguments[0],
-                    _ => null,
-                };
+                    case BoundCollectionElementInitializer collectionInitializer:
+                        return getCollectionInitializerElement(collectionInitializer);
+                    case BoundDynamicCollectionElementInitializer dynamicInitializer:
+                        return dynamicInitializer.Arguments[0];
+                }
+                if (throwOnErrors)
+                {
+                    throw ExceptionUtilities.UnexpectedValue(element);
+                }
+                switch (element)
+                {
+                    case BoundCall call:
+                        return call.Arguments[call.InvokedAsExtensionMethod ? 1 : 0];
+                    default:
+                        return element;
+                }
             }
             return element;
 
@@ -1422,8 +1513,9 @@ private void GenerateImplicitConversionErrorForCollectionExpression(
                     }
 
                     if (elements.Length > 0 &&
-                        !HasCollectionExpressionApplicableAddMethod(node.Syntax, targetType, elementType, addMethods: out _, diagnostics))
+                        !HasCollectionExpressionAddMethod(node.Syntax, targetType))
                     {
+                        Error(diagnostics, ErrorCode.ERR_CollectionExpressionMissingAdd_New, node.Syntax, targetType);
                         reportedErrors = true;
                     }
                 }

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

@@ -194,7 +194,7 @@ protected override Conversion GetCollectionExpressionConversion(
                 }
 
                 if (elements.Length > 0 &&
-                    !_binder.HasCollectionExpressionApplicableAddMethod(syntax, targetType, elementType, addMethods: out _, BindingDiagnosticBag.Discarded))
+                    !_binder.HasCollectionExpressionAddMethod(syntax, targetType))
                 {
                     return Conversion.NoConversion;
                 }

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -6865,6 +6865,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_CollectionExpressionMissingAdd" xml:space="preserve">
     <value>Collection expression type must have an applicable instance or extension method 'Add' that can be called with an argument of iteration type '{0}'. The best overloaded method is '{1}'.</value>
   </data>
+  <data name="ERR_CollectionExpressionMissingAdd_New" xml:space="preserve">
+    <value>Collection expression type '{0}' must have an instance or extension method 'Add' that can be called with a single argument.</value>
+  </data>
   <data name="ERR_CollectionBuilderAttributeInvalidType" xml:space="preserve">
     <value>The CollectionBuilderAttribute builder type must be a non-generic class or struct.</value>
   </data>

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

@@ -2301,6 +2301,7 @@ internal enum ErrorCode
         ERR_ParamsCollectionMissingConstructor = 9228,
 
         ERR_NoModifiersOnUsing = 9229,
+        ERR_CollectionExpressionMissingAdd_New = 9230, // PROTOTYPE: Replace ERR_CollectionExpressionMissingAdd.
 
         #endregion
 

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

@@ -2431,6 +2431,7 @@ internal static bool IsBuildOnlyDiagnostic(ErrorCode code)
                 case ErrorCode.ERR_ParamsCollectionExtensionAddMethod:
                 case ErrorCode.ERR_ParamsCollectionMissingConstructor:
                 case ErrorCode.ERR_NoModifiersOnUsing:
+                case ErrorCode.ERR_CollectionExpressionMissingAdd_New:
                     return false;
                 default:
                     // NOTE: All error codes must be explicitly handled in this switch statement

src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionExpression.cs

@@ -118,7 +118,7 @@ static BoundNode unwrapListElement(BoundCollectionExpression node, BoundNode ele
                 if (element is BoundCollectionExpressionSpreadElement spreadElement)
                 {
                     Debug.Assert(spreadElement.IteratorBody is { });
-                    var iteratorBody = Binder.GetUnderlyingCollectionExpressionElement(node, ((BoundExpressionStatement)spreadElement.IteratorBody).Expression);
+                    var iteratorBody = Binder.GetUnderlyingCollectionExpressionElement(node, ((BoundExpressionStatement)spreadElement.IteratorBody).Expression, throwOnErrors: true);
                     Debug.Assert(iteratorBody is { });
                     return spreadElement.Update(
                         spreadElement.Expression,
@@ -131,7 +131,7 @@ static BoundNode unwrapListElement(BoundCollectionExpression node, BoundNode ele
                 }
                 else
                 {
-                    var result = Binder.GetUnderlyingCollectionExpressionElement(node, (BoundExpression)element);
+                    var result = Binder.GetUnderlyingCollectionExpressionElement(node, (BoundExpression)element, throwOnErrors: true);
                     Debug.Assert(result is { });
                     return result;
                 }

src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs

@@ -1257,13 +1257,14 @@ private IOperation CreateBoundCollectionExpressionElement(BoundCollectionExpress
         {
             return element is BoundCollectionExpressionSpreadElement spreadElement ?
                 CreateBoundCollectionExpressionSpreadElement(expr, spreadElement) :
-                Create(Binder.GetUnderlyingCollectionExpressionElement(expr, (BoundExpression)element) ?? element);
+                Create(Binder.GetUnderlyingCollectionExpressionElement(expr, (BoundExpression)element, throwOnErrors: false));
         }
 
         private ISpreadOperation CreateBoundCollectionExpressionSpreadElement(BoundCollectionExpression expr, BoundCollectionExpressionSpreadElement element)
         {
-            var iteratorBody = ((BoundExpressionStatement?)element.IteratorBody)?.Expression;
-            var iteratorItem = Binder.GetUnderlyingCollectionExpressionElement(expr, iteratorBody);
+            var iteratorItem = element.IteratorBody is { } iteratorBody ?
+                Binder.GetUnderlyingCollectionExpressionElement(expr, ((BoundExpressionStatement)iteratorBody).Expression, throwOnErrors: false) :
+                null;
             var collection = Create(element.Expression);
             SyntaxNode syntax = element.Syntax;
             bool isImplicit = element.WasCompilerGenerated;