Collection literals natural type

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

@@ -409,7 +409,14 @@ private BoundExpression CheckValue(BoundExpression expr, BindValueKind valueKind
                     expr = BindIndexerDefaultArguments((BoundIndexerAccess)expr, valueKind, diagnostics);
                     break;
 
-                case BoundKind.UnconvertedObjectCreationExpression:
+                case BoundKind.UnconvertedObjectCreationExpression: // PROTOTYPE: What is the effect of commenting out this case? Add a corresponding test for collection literals (next case).
+                    if (valueKind == BindValueKind.RValue)
+                    {
+                        return expr;
+                    }
+                    break;
+
+                case BoundKind.UnconvertedCollectionLiteralExpression:
                     if (valueKind == BindValueKind.RValue)
                     {
                         return expr;

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

@@ -386,6 +386,9 @@ internal BoundExpression BindToNaturalType(BoundExpression expression, BindingDi
                         result = RebindSimpleBinaryOperatorAsConverted(unconvertedBinaryOperator, diagnostics);
                     }
                     break;
+                case BoundUnconvertedCollectionLiteralExpression collectionLiteral:
+                    result = ConvertCollectionLiteralExpressionToNaturalType(collectionLiteral, diagnostics);
+                    break;
                 default:
                     result = expression;
                     break;
@@ -4490,7 +4493,10 @@ private BoundExpression BindCollectionLiteralExpression(CollectionCreationExpres
             {
                 builder.Add(bindElement(element, diagnostics));
             }
-            return new BoundUnconvertedCollectionLiteralExpression(syntax, builder.ToImmutableAndFree(), this);
+
+            var initializers = builder.ToImmutableAndFree();
+            var naturalType = InferCollectionLiteralNaturalType(initializers);
+            return new BoundUnconvertedCollectionLiteralExpression(syntax, initializers, this, type: naturalType);
 
             BoundExpression bindElement(CollectionElementSyntax syntax, BindingDiagnosticBag diagnostics)
             {
@@ -5510,7 +5516,7 @@ private BoundExpression BindUnexpectedComplexElementInitializer(InitializerExpre
         }
 
         private BoundExpression BindCollectionInitializerElementAddMethod(
-            ExpressionSyntax elementInitializer,
+            SyntaxNode elementInitializer,
             ImmutableArray<BoundExpression> boundElementInitializerExpressions,
             bool hasEnumerableInitializerType,
             Binder collectionInitializerAddMethodBinder,

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

@@ -60,6 +60,7 @@ internal bool NeedsToBeConverted()
                 case BoundKind.UnconvertedConditionalOperator:
                 case BoundKind.DefaultLiteral:
                 case BoundKind.UnconvertedInterpolatedString:
+                case BoundKind.UnconvertedCollectionLiteralExpression:
                     return true;
                 case BoundKind.StackAllocArrayCreation:
                     // A BoundStackAllocArrayCreation is given a null type when it is in a

src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml

@@ -1867,12 +1867,10 @@
   </Node>
 
   <!--
-  A target-typed collection literal expression.
+  An unconverted collection literal expression.
   It does not survive past initial binding.
   -->
   <Node Name="BoundUnconvertedCollectionLiteralExpression" Base="BoundExpression">
-    <!-- Type is not significant for this node type; always null -->
-    <Field Name="Type" Type="TypeSymbol?" Override="true" Null="always"/>
     <!-- Collection literal elements. -->
     <Field Name="Initializers" Type="ImmutableArray&lt;BoundExpression&gt;"/>
     <Field Name="Binder" Type="Binder" Null="disallow"/>

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -6789,6 +6789,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_CollectionLiteralElementNotImplemented" xml:space="preserve">
     <value>Support for collection literal dictionary and spread elements has not been implemented.</value>
   </data>
+  <data name="ERR_ImplicitlyTypedCollectionLiteralNoBestType" xml:space="preserve">
+    <value>No best type found for implicitly-typed collection literal.</value>
+  </data>
   <data name="ERR_EqualityContractRequiresGetter" xml:space="preserve">
     <value>Record equality contract property '{0}' must have a get accessor.</value>
   </data>

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

@@ -2190,6 +2190,7 @@ internal enum ErrorCode
         ERR_CollectionLiteralTargetTypeNotConstructible = 9500, // PROTOTYPE: Update error numbers.
         ERR_ExpressionTreeContainsCollectionLiteral = 9501,
         ERR_CollectionLiteralElementNotImplemented = 9502, // PROTOTYPE: Temporary error until feature has been implemented.
+        ERR_ImplicitlyTypedCollectionLiteralNoBestType = 9503,
 
         #endregion
 

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

@@ -2310,6 +2310,7 @@ internal static bool IsBuildOnlyDiagnostic(ErrorCode code)
                 case ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible:
                 case ErrorCode.ERR_ExpressionTreeContainsCollectionLiteral:
                 case ErrorCode.ERR_CollectionLiteralElementNotImplemented:
+                case ErrorCode.ERR_ImplicitlyTypedCollectionLiteralNoBestType:
                     return false;
                 default:
                     // NOTE: All error codes must be explicitly handled in this switch statement