Collection expressions: require Add method callable with single argum…

…ent 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,6 +1285,85 @@ 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
@@ -1422,8 +1501,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