diff --git a/src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs b/src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs
index 97e870a509fa8..4eb8f05be9181 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder.ValueChecks.cs
@@ -3804,6 +3804,11 @@ internal uint GetValEscape(BoundExpression expr, uint scopeOfTheContainingExpres
                     var switchExpr = (BoundSwitchExpression)expr;
                     return GetValEscape(switchExpr.SwitchArms.SelectAsArray(a => a.Value), scopeOfTheContainingExpression);
 
+                case BoundKind.ArrayOrSpanCollectionLiteralExpression:
+                case BoundKind.CollectionInitializerCollectionLiteralExpression:
+                    // PROTOTYPE: Revisit if spans may be optimized to avoid heap allocation.
+                    return CallingMethodScope;
+
                 default:
                     // in error situations some unexpected nodes could make here
                     // returning "scopeOfTheContainingExpression" seems safer than throwing.
@@ -4282,6 +4287,11 @@ internal bool CheckValEscape(SyntaxNode node, BoundExpression expr, uint escapeF
 
                     return true;
 
+                case BoundKind.ArrayOrSpanCollectionLiteralExpression:
+                case BoundKind.CollectionInitializerCollectionLiteralExpression:
+                    // PROTOTYPE: Revisit if spans may be optimized to avoid heap allocation.
+                    return true;
+
                 default:
                     // in error situations some unexpected nodes could make here
                     // returning "false" seems safer than throwing.
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
index 6ff334f1c130c..ad1825936f54f 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
@@ -230,6 +230,18 @@ BoundExpression createConversion(
                     return ConvertObjectCreationExpression(syntax, (BoundUnconvertedObjectCreationExpression)source, conversion, isCast, destination, conversionGroupOpt, wasCompilerGenerated, diagnostics);
                 }
 
+                if (conversion.IsCollectionLiteral)
+                {
+                    return ConvertCollectionLiteralExpression(
+                        (BoundUnconvertedCollectionLiteralExpression)source,
+                        conversion,
+                        isCast,
+                        destination,
+                        conversionGroupOpt,
+                        wasCompilerGenerated,
+                        diagnostics);
+                }
+
                 if (source.Kind == BoundKind.UnconvertedConditionalOperator)
                 {
                     Debug.Assert(source.Type is null);
@@ -404,6 +416,187 @@ static BoundExpression bindObjectCreationExpression(
             }
         }
 
+        private BoundExpression ConvertCollectionLiteralExpression(
+            BoundUnconvertedCollectionLiteralExpression node,
+            Conversion conversion,
+            bool isCast,
+            TypeSymbol targetType,
+            ConversionGroup? conversionGroupOpt,
+            bool wasCompilerGenerated,
+            BindingDiagnosticBag diagnostics)
+        {
+            var syntax = (CSharpSyntaxNode)node.Syntax;
+            var implicitReceiver = new BoundObjectOrCollectionValuePlaceholder(syntax, isNewInstance: true, targetType) { WasCompilerGenerated = true };
+            TypeSymbol? elementType;
+            BoundCollectionLiteralExpression collectionLiteral;
+
+            if (targetType is ArrayTypeSymbol arrayType)
+            {
+                if (!arrayType.IsSZArray)
+                {
+                    Error(diagnostics, ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, syntax, targetType);
+                }
+                collectionLiteral = bindArrayOrSpan(syntax, spanConstructor: null, implicitReceiver, node.Initializers, arrayType.ElementType, diagnostics);
+            }
+            else if (isSpanType(targetType, WellKnownType.System_Span_T, out elementType))
+            {
+                var spanConstructor = getSpanConstructor(syntax, targetType, WellKnownMember.System_Span_T__ctor_Array, diagnostics);
+                collectionLiteral = bindArrayOrSpan(syntax, spanConstructor, implicitReceiver, node.Initializers, elementType, diagnostics);
+            }
+            else if (isSpanType(targetType, WellKnownType.System_ReadOnlySpan_T, out elementType))
+            {
+                var spanConstructor = getSpanConstructor(syntax, targetType, WellKnownMember.System_ReadOnlySpan_T__ctor_Array, diagnostics);
+                collectionLiteral = bindArrayOrSpan(syntax, spanConstructor, implicitReceiver, node.Initializers, elementType, diagnostics);
+            }
+            else
+            {
+                collectionLiteral = bindCollectionInitializer(syntax, implicitReceiver, node.Initializers, diagnostics);
+            }
+
+            return new BoundConversion(
+                syntax,
+                collectionLiteral,
+                conversion,
+                node.Binder.CheckOverflowAtRuntime,
+                explicitCastInCode: isCast && !wasCompilerGenerated,
+                conversionGroupOpt,
+                collectionLiteral.ConstantValueOpt,
+                targetType);
+
+            bool isSpanType(TypeSymbol targetType, WellKnownType spanType, [NotNullWhen(true)] out TypeSymbol? elementType)
+            {
+                if (targetType is NamedTypeSymbol { Arity: 1 } namedType
+                    && TypeSymbol.Equals(namedType.OriginalDefinition, Compilation.GetWellKnownType(spanType), TypeCompareKind.AllIgnoreOptions))
+                {
+                    elementType = namedType.TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0].Type;
+                    return true;
+                }
+                elementType = null;
+                return false;
+            }
+
+            BoundArrayOrSpanCollectionLiteralExpression bindArrayOrSpan(
+                CSharpSyntaxNode syntax,
+                MethodSymbol? spanConstructor,
+                BoundObjectOrCollectionValuePlaceholder implicitReceiver,
+                ImmutableArray<BoundExpression> elements,
+                TypeSymbol elementType,
+                BindingDiagnosticBag diagnostics)
+            {
+                var builder = ArrayBuilder<BoundExpression>.GetInstance(elements.Length);
+                foreach (var element in elements)
+                {
+                    builder.Add(convertArrayElement(element, elementType, diagnostics));
+                }
+                return new BoundArrayOrSpanCollectionLiteralExpression(
+                    syntax,
+                    spanConstructor,
+                    naturalTypeOpt: null,
+                    wasTargetTyped: true,
+                    implicitReceiver,
+                    builder.ToImmutableAndFree(),
+                    targetType)
+                { WasCompilerGenerated = wasCompilerGenerated };
+            }
+
+            BoundCollectionInitializerCollectionLiteralExpression bindCollectionInitializer(
+                CSharpSyntaxNode syntax,
+                BoundObjectOrCollectionValuePlaceholder implicitReceiver,
+                ImmutableArray<BoundExpression> elements,
+                BindingDiagnosticBag diagnostics)
+            {
+                BoundExpression collectionCreation;
+                if (targetType is NamedTypeSymbol namedType)
+                {
+                    var analyzedArguments = AnalyzedArguments.GetInstance();
+                    collectionCreation = BindClassCreationExpression(syntax, namedType.Name, syntax, namedType, analyzedArguments, diagnostics);
+                    collectionCreation.WasCompilerGenerated = true;
+                    analyzedArguments.Free();
+                }
+                else if (targetType is TypeParameterSymbol typeParameter)
+                {
+                    var arguments = AnalyzedArguments.GetInstance();
+                    collectionCreation = BindTypeParameterCreationExpression(syntax, typeParameter, arguments, initializerOpt: null, typeSyntax: syntax, wasTargetTyped: true, diagnostics);
+                    arguments.Free();
+                }
+                else
+                {
+                    collectionCreation = new BoundBadExpression(syntax, LookupResultKind.NotCreatable, ImmutableArray<Symbol?>.Empty, ImmutableArray<BoundExpression>.Empty, targetType);
+                }
+
+                bool hasEnumerableInitializerType = collectionTypeImplementsIEnumerable(targetType, syntax, diagnostics);
+                if (!hasEnumerableInitializerType && !targetType.IsErrorType())
+                {
+                    Error(diagnostics, ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, syntax, targetType);
+                }
+
+                var collectionInitializerAddMethodBinder = this.WithAdditionalFlags(BinderFlags.CollectionInitializerAddMethod);
+                var builder = ArrayBuilder<BoundExpression>.GetInstance(node.Initializers.Length);
+                foreach (var element in node.Initializers)
+                {
+                    var result = BindCollectionInitializerElementAddMethod(
+                        (ExpressionSyntax)element.Syntax,
+                        ImmutableArray.Create(element),
+                        hasEnumerableInitializerType,
+                        collectionInitializerAddMethodBinder,
+                        diagnostics,
+                        implicitReceiver);
+                    result.WasCompilerGenerated = true;
+                    builder.Add(result);
+                }
+                return new BoundCollectionInitializerCollectionLiteralExpression(
+                    syntax,
+                    collectionCreation,
+                    naturalTypeOpt: null, // PROTOTYPE: Support natural type.
+                    wasTargetTyped: true, // PROTOTYPE: Support natural type.
+                    implicitReceiver,
+                    builder.ToImmutableAndFree(),
+                    targetType)
+                { WasCompilerGenerated = wasCompilerGenerated };
+            }
+
+            MethodSymbol? getSpanConstructor(CSharpSyntaxNode syntax, TypeSymbol spanType, WellKnownMember spanMember, BindingDiagnosticBag diagnostics)
+            {
+                return (MethodSymbol?)GetWellKnownTypeMember(spanMember, diagnostics, syntax: syntax)?.SymbolAsMember((NamedTypeSymbol)spanType);
+            }
+
+            bool collectionTypeImplementsIEnumerable(TypeSymbol targetType, CSharpSyntaxNode syntax, BindingDiagnosticBag diagnostics)
+            {
+                // This implementation differs from CollectionInitializerTypeImplementsIEnumerable().
+                // That method checks for an implicit conversion from IEnumerable to the collection type,
+                // but that would allow: Nullable<StructCollection> s = [];
+                var ienumerableType = GetSpecialType(SpecialType.System_Collections_IEnumerable, diagnostics, syntax);
+                var allInterfaces = targetType is TypeParameterSymbol typeParameter
+                    ? typeParameter.AllEffectiveInterfacesNoUseSiteDiagnostics
+                    : targetType.AllInterfacesNoUseSiteDiagnostics;
+                return allInterfaces.Any(static (a, b) => a.Equals(b, TypeCompareKind.AllIgnoreOptions), ienumerableType);
+            }
+
+            BoundExpression convertArrayElement(BoundExpression element, TypeSymbol elementType, BindingDiagnosticBag diagnostics)
+            {
+                CompoundUseSiteInfo<AssemblySymbol> useSiteInfo = GetNewCompoundUseSiteInfo(diagnostics);
+                var conversion = Conversions.ClassifyImplicitConversionFromExpression(element, elementType, ref useSiteInfo);
+                diagnostics.Add(element.Syntax, useSiteInfo);
+                bool hasErrors = !conversion.IsValid;
+                if (hasErrors)
+                {
+                    GenerateImplicitConversionError(diagnostics, element.Syntax, conversion, element, elementType);
+                }
+                var result = CreateConversion(
+                    element.Syntax,
+                    element,
+                    conversion,
+                    isCast: false,
+                    conversionGroupOpt: null,
+                    wasCompilerGenerated: true,
+                    destination: elementType,
+                    diagnostics: diagnostics,
+                    hasErrors: hasErrors);
+                result.WasCompilerGenerated = true;
+                return result;
+            }
+        }
+
         /// <summary>
         /// Rewrite the subexpressions in a conditional expression to convert the whole thing to the destination type.
         /// </summary>
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
index dd32d6393c35c..64222d1f7db87 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Expressions.cs
@@ -755,8 +755,7 @@ private BoundExpression BindExpressionInternal(ExpressionSyntax node, BindingDia
                     return BadExpression(node);
 
                 case SyntaxKind.CollectionCreationExpression:
-                    // PROTOTYPE: Implement binding for this.
-                    return BadExpression(node);
+                    return BindCollectionLiteralExpression((CollectionCreationExpressionSyntax)node, diagnostics);
 
                 case SyntaxKind.NullableType:
                     // Not reachable during method body binding, but
@@ -4482,6 +4481,41 @@ BoundExpression bindObjectCreationExpression(ObjectCreationExpressionSyntax node
             }
         }
 
+        private BoundExpression BindCollectionLiteralExpression(CollectionCreationExpressionSyntax syntax, BindingDiagnosticBag diagnostics)
+        {
+            MessageID.IDS_FeatureCollectionLiterals.CheckFeatureAvailability(diagnostics, syntax, syntax.OpenBracketToken.GetLocation());
+
+            var builder = ArrayBuilder<BoundExpression>.GetInstance(syntax.Elements.Count);
+            foreach (var element in syntax.Elements)
+            {
+                builder.Add(bindElement(element, diagnostics));
+            }
+            return new BoundUnconvertedCollectionLiteralExpression(syntax, builder.ToImmutableAndFree(), this);
+
+            BoundExpression bindElement(CollectionElementSyntax syntax, BindingDiagnosticBag diagnostics)
+            {
+                switch (syntax)
+                {
+                    case ExpressionElementSyntax expressionElementSyntax:
+                        return BindValue(expressionElementSyntax.Expression, diagnostics, BindValueKind.RValue);
+
+                    case DictionaryElementSyntax dictionaryElementSyntax:
+                        _ = BindValue(dictionaryElementSyntax.KeyExpression, diagnostics, BindValueKind.RValue);
+                        _ = BindValue(dictionaryElementSyntax.ValueExpression, diagnostics, BindValueKind.RValue);
+                        Error(diagnostics, ErrorCode.ERR_CollectionLiteralElementNotImplemented, syntax);
+                        return BadExpression(syntax);
+
+                    case SpreadElementSyntax spreadElementSyntax:
+                        _ = BindValue(spreadElementSyntax.Expression, diagnostics, BindValueKind.RValue);
+                        Error(diagnostics, ErrorCode.ERR_CollectionLiteralElementNotImplemented, syntax);
+                        return BadExpression(syntax);
+
+                    default:
+                        throw ExceptionUtilities.UnexpectedValue(syntax.Kind());
+                }
+            }
+        }
+
         private BoundExpression BindDelegateCreationExpression(ObjectCreationExpressionSyntax node, NamedTypeSymbol type, BindingDiagnosticBag diagnostics)
         {
             AnalyzedArguments analyzedArguments = AnalyzedArguments.GetInstance();
@@ -4756,7 +4790,6 @@ private BoundExpression MakeBadExpressionForObjectCreation(SyntaxNode node, Type
 
             return new BoundBadExpression(node, LookupResultKind.NotCreatable, ImmutableArray.Create<Symbol?>(type), children.ToImmutableAndFree(), type) { WasCompilerGenerated = wasCompilerGenerated };
         }
-#nullable disable
 
         private BoundObjectInitializerExpressionBase BindInitializerExpression(
             InitializerExpressionSyntax syntax,
@@ -4788,6 +4821,7 @@ private BoundObjectInitializerExpressionBase BindInitializerExpression(
                     throw ExceptionUtilities.Unreachable();
             }
         }
+#nullable disable
 
         private BoundExpression BindInitializerExpressionOrValue(
             ExpressionSyntax syntax,
@@ -5971,8 +6005,9 @@ private BoundExpression BindTypeParameterCreationExpression(ObjectCreationExpres
             return result;
         }
 
+#nullable enable
         private BoundExpression BindTypeParameterCreationExpression(
-            SyntaxNode node, TypeParameterSymbol typeParameter, AnalyzedArguments analyzedArguments, InitializerExpressionSyntax initializerOpt,
+            SyntaxNode node, TypeParameterSymbol typeParameter, AnalyzedArguments analyzedArguments, InitializerExpressionSyntax? initializerOpt,
             SyntaxNode typeSyntax, bool wasTargetTyped, BindingDiagnosticBag diagnostics)
         {
             if (!typeParameter.HasConstructorConstraint && !typeParameter.IsValueType)
@@ -5998,6 +6033,7 @@ private BoundExpression BindTypeParameterCreationExpression(
 
             return MakeBadExpressionForObjectCreation(node, typeParameter, analyzedArguments, initializerOpt, typeSyntax, diagnostics);
         }
+#nullable disable
 
         /// <summary>
         /// Given the type containing constructors, gets the list of candidate instance constructors and uses overload resolution to determine which one should be called.
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs
index ff2fe9c168f7d..9261886f7c650 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/Conversion.cs
@@ -231,6 +231,7 @@ internal static Conversion GetTrivialConversion(ConversionKind kind)
         internal static Conversion ImplicitEnumeration => new Conversion(ConversionKind.ImplicitEnumeration);
         internal static Conversion ImplicitThrow => new Conversion(ConversionKind.ImplicitThrow);
         internal static Conversion ObjectCreation => new Conversion(ConversionKind.ObjectCreation);
+        internal static Conversion CollectionLiteral => new Conversion(ConversionKind.CollectionLiteral);
         internal static Conversion AnonymousFunction => new Conversion(ConversionKind.AnonymousFunction);
         internal static Conversion Boxing => new Conversion(ConversionKind.Boxing);
         internal static Conversion NullLiteral => new Conversion(ConversionKind.NullLiteral);
@@ -631,6 +632,11 @@ public bool IsObjectCreation
             }
         }
 
+        /// <summary>
+        /// Returns true if the conversion is an implicit collection literal expression conversion.
+        /// </summary>
+        public bool IsCollectionLiteral => Kind == ConversionKind.CollectionLiteral;
+
         /// <summary>
         /// Returns true if the conversion is an implicit switch expression conversion.
         /// </summary>
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKind.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKind.cs
index 7656918721763..499878083c7a5 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKind.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKind.cs
@@ -63,6 +63,7 @@ internal enum ConversionKind : byte
 
         DefaultLiteral, // a conversion from a `default` literal to any type
         ObjectCreation, // a conversion from a `new()` expression to any type
+        CollectionLiteral, // a conversion from a collection literal to any type
 
         InterpolatedStringHandler, // A conversion from an interpolated string literal to a type attributed with InterpolatedStringBuilderAttribute
     }
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKindExtensions.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKindExtensions.cs
index 08ebed29d4a48..ed3e5f029b635 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKindExtensions.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionKindExtensions.cs
@@ -51,6 +51,7 @@ public static bool IsImplicitConversion(this ConversionKind conversionKind)
                 case StackAllocToSpanType:
                 case ImplicitPointer:
                 case ObjectCreation:
+                case CollectionLiteral:
                     return true;
 
                 case ExplicitNumeric:
diff --git a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs
index ea9a3976650c8..1eaff9c66d5ac 100644
--- a/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Semantics/Conversions/ConversionsBase.cs
@@ -571,6 +571,7 @@ public Conversion ClassifyStandardConversion(BoundExpression sourceExpression, T
             return Conversion.NoConversion;
         }
 
+        // PROTOTYPE: Ensure collection literal conversions are not considered standard implicit conversions.
         private static bool IsStandardImplicitConversionFromExpression(ConversionKind kind)
         {
             if (IsStandardImplicitConversionFromType(kind))
@@ -1094,6 +1095,9 @@ private Conversion ClassifyImplicitBuiltInConversionFromExpression(BoundExpressi
 
                 case BoundKind.UnconvertedObjectCreationExpression:
                     return Conversion.ObjectCreation;
+
+                case BoundKind.UnconvertedCollectionLiteralExpression:
+                    return Conversion.CollectionLiteral;
             }
 
             return Conversion.NoConversion;
diff --git a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
index db0a64e70a2d5..523c2fcc16961 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
+++ b/src/Compilers/CSharp/Portable/BoundTree/BoundNodes.xml
@@ -1866,6 +1866,38 @@
     <Field Name="WasTargetTyped" Type="bool" PropertyOverrides="true"/>
   </Node>
   
+  <!--
+  A target-typed 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"/>
+  </Node>
+
+  <AbstractNode Name="BoundCollectionLiteralExpression" Base="BoundExpression">
+    <!-- Non-null type is required for this node kind -->
+    <Field Name="Type" Type="TypeSymbol" Override="true" Null="disallow"/>
+    <!-- Natural type is preserved for the purpose of semantic model. Can be `null`. -->
+    <Field Name="NaturalTypeOpt" Type="TypeSymbol?" Null="allow"/>
+    <Field Name="WasTargetTyped" Type="bool" />
+    <!-- An expression placeholder value representing the initialized collection. -->
+    <Field Name="Placeholder" Type="BoundObjectOrCollectionValuePlaceholder" Null="disallow" SkipInVisitor="true"/>
+    <!-- Collection literal elements. -->
+    <Field Name="Initializers" Type="ImmutableArray&lt;BoundExpression&gt;"/>
+  </AbstractNode>
+
+  <Node Name="BoundArrayOrSpanCollectionLiteralExpression" Base="BoundCollectionLiteralExpression">
+    <!-- Constructor to create a span from an array. -->
+    <Field Name="SpanConstructor" Type="MethodSymbol?" Null="allow"/>
+  </Node>
+
+  <Node Name="BoundCollectionInitializerCollectionLiteralExpression" Base="BoundCollectionLiteralExpression">
+    <Field Name="CollectionCreation" Type="BoundExpression" Null="disallow" SkipInVisitor="true"/>
+  </Node>
 
   <!-- 
   Tuple literals can exist in two forms - literal and converted literal.
diff --git a/src/Compilers/CSharp/Portable/BoundTree/Formatting.cs b/src/Compilers/CSharp/Portable/BoundTree/Formatting.cs
index 70bf08291164a..7938cffe78b3b 100644
--- a/src/Compilers/CSharp/Portable/BoundTree/Formatting.cs
+++ b/src/Compilers/CSharp/Portable/BoundTree/Formatting.cs
@@ -167,6 +167,12 @@ public override object Display
             => (Type is null) ? MessageID.IDS_FeatureTargetTypedConditional.Localize() : base.Display;
     }
 
+    internal partial class BoundUnconvertedCollectionLiteralExpression
+    {
+        public override object Display
+            => (Type is null) ? MessageID.IDS_FeatureCollectionLiterals.Localize() : base.Display;
+    }
+
     internal partial class BoundPassByCopy
     {
         public override object Display => Expression.Display;
diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx
index b60ab0cfc078e..5e929dd058c11 100644
--- a/src/Compilers/CSharp/Portable/CSharpResources.resx
+++ b/src/Compilers/CSharp/Portable/CSharpResources.resx
@@ -6777,6 +6777,18 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="IDS_FeatureVarianceSafetyForStaticInterfaceMembers" xml:space="preserve">
     <value>variance safety for static interface members</value>
   </data>
+  <data name="IDS_FeatureCollectionLiterals" xml:space="preserve">
+    <value>collection literals</value>
+  </data>
+  <data name="ERR_CollectionLiteralTargetTypeNotConstructible" xml:space="preserve">
+    <value>Cannot initialize type '{0}' with a collection literal because the type is not constructible.</value>
+  </data>
+  <data name="ERR_ExpressionTreeContainsCollectionLiteral" xml:space="preserve">
+    <value>An expression tree may not contain a collection literal.</value>
+  </data>
+  <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_EqualityContractRequiresGetter" xml:space="preserve">
     <value>Record equality contract property '{0}' must have a get accessor.</value>
   </data>
diff --git a/src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs b/src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs
index 8588bac47319b..836737515fb68 100644
--- a/src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs
+++ b/src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs
@@ -2183,6 +2183,25 @@ internal CSharpTypeInfo GetTypeInfoForNode(
                         conversion = Conversion.Identity;
                     }
                 }
+                else if (boundExpr is BoundCollectionLiteralExpression { WasTargetTyped: true } convertedCollection)
+                {
+                    if (highestBoundExpr is BoundConversion { ConversionKind: ConversionKind.CollectionLiteral, Conversion: var convertedCollectionConversion })
+                    {
+                        // There was an implicit cast.
+                        type = convertedCollection.NaturalTypeOpt;
+                        convertedType = convertedCollection.Type;
+                        convertedNullability = convertedCollection.TopLevelNullability;
+                        conversion = convertedCollectionConversion.IsValid ? convertedCollectionConversion : Conversion.NoConversion;
+                    }
+                    else
+                    {
+                        Debug.Assert(false); // PROTOTYPE: Add test.
+                        // There was an explicit cast on top of this
+                        type = convertedCollection.NaturalTypeOpt;
+                        (convertedType, convertedNullability) = (type, nullability);
+                        conversion = Conversion.Identity;
+                    }
+                }
                 else if (highestBoundExpr != null && highestBoundExpr != boundExpr && highestBoundExpr.HasExpressionType())
                 {
                     (convertedType, convertedNullability) = getTypeAndNullability(highestBoundExpr);
diff --git a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
index 9583249e1953b..8b1d6d75eb6ea 100644
--- a/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
+++ b/src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs
@@ -2084,11 +2084,6 @@ static void addIdentifiers(CSharpSyntaxNode? node, ConcurrentDictionary<Identifi
                                 // These nodes do not have anything interesting for us
                                 return false;
 
-                            case CollectionCreationExpressionSyntax:
-                                // PROTOTYPE: Remove this case after binding of collection literals is added,
-                                // and test primary constructor parameters referenced in collection literals.
-                                return false;
-
                             case ExpressionSyntax expression:
                                 if (SyntaxFacts.IsInTypeOnlyContext(expression) &&
                                     !(expression.Parent is BinaryExpressionSyntax { RawKind: (int)SyntaxKind.IsExpression } isExpression &&
diff --git a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
index 1f079437c4642..f1b25b90547e1 100644
--- a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
+++ b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs
@@ -2186,6 +2186,11 @@ internal enum ErrorCode
         ERR_BadRefInUsingAlias = 9130,
         ERR_BadUnsafeInUsingDirective = 9131,
         ERR_BadNullableReferenceTypeInUsingAlias = 9132,
+
+        ERR_CollectionLiteralTargetTypeNotConstructible = 9500, // PROTOTYPE: Update error numbers.
+        ERR_ExpressionTreeContainsCollectionLiteral = 9501,
+        ERR_CollectionLiteralElementNotImplemented = 9502, // PROTOTYPE: Temporary error until feature has been implemented.
+
         #endregion
 
         // Note: you will need to do the following after adding warnings:
diff --git a/src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs b/src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs
index fb37825ffa6c3..1cf9037f420d1 100644
--- a/src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs
+++ b/src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs
@@ -2307,6 +2307,9 @@ internal static bool IsBuildOnlyDiagnostic(ErrorCode code)
                 case ErrorCode.ERR_BadRefInUsingAlias:
                 case ErrorCode.ERR_BadUnsafeInUsingDirective:
                 case ErrorCode.ERR_BadNullableReferenceTypeInUsingAlias:
+                case ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible:
+                case ErrorCode.ERR_ExpressionTreeContainsCollectionLiteral:
+                case ErrorCode.ERR_CollectionLiteralElementNotImplemented:
                     return false;
                 default:
                     // NOTE: All error codes must be explicitly handled in this switch statement
diff --git a/src/Compilers/CSharp/Portable/Errors/MessageID.cs b/src/Compilers/CSharp/Portable/Errors/MessageID.cs
index e55e7ad573ffb..30acfb023dd7b 100644
--- a/src/Compilers/CSharp/Portable/Errors/MessageID.cs
+++ b/src/Compilers/CSharp/Portable/Errors/MessageID.cs
@@ -265,6 +265,7 @@ internal enum MessageID
 
         IDS_FeaturePrimaryConstructors = MessageBase + 12833,
         IDS_FeatureUsingTypeAlias = MessageBase + 12834,
+        IDS_FeatureCollectionLiterals = MessageBase + 12900, // PROTOTYPE: Update message number.
     }
 
     // Message IDs may refer to strings that need to be localized.
@@ -393,6 +394,7 @@ internal static LanguageVersion RequiredVersion(this MessageID feature)
                 case MessageID.IDS_FeatureLambdaParamsArray: // semantic check
                 case MessageID.IDS_FeaturePrimaryConstructors: // declaration table check
                 case MessageID.IDS_FeatureUsingTypeAlias: // semantic check
+                case MessageID.IDS_FeatureCollectionLiterals: // semantic check
                     return LanguageVersion.Preview;
 
                 // C# 11.0 features.
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass.cs
index ee6e5f6d613a0..5a5cd843eb64f 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/AbstractFlowPass.cs
@@ -1919,12 +1919,37 @@ protected virtual void VisitLvalueParameter(BoundParameter node)
 
         public override BoundNode VisitObjectCreationExpression(BoundObjectCreationExpression node)
         {
-
             VisitArguments(node.Arguments, node.ArgumentRefKindsOpt, node.Constructor);
             VisitRvalue(node.InitializerExpressionOpt);
             return null;
         }
 
+        public override BoundNode VisitArrayOrSpanCollectionLiteralExpression(BoundArrayOrSpanCollectionLiteralExpression node)
+        {
+            VisitCollectionLiteralExpression(node);
+            return null;
+        }
+
+        public override BoundNode VisitCollectionInitializerCollectionLiteralExpression(BoundCollectionInitializerCollectionLiteralExpression node)
+        {
+            VisitCollectionLiteralExpression(node);
+            return null;
+        }
+
+        protected virtual void VisitCollectionLiteralExpression(BoundCollectionLiteralExpression node)
+        {
+            foreach (var initializer in node.Initializers)
+            {
+                VisitRvalue(initializer);
+            }
+        }
+
+        public override BoundNode VisitUnconvertedCollectionLiteralExpression(BoundUnconvertedCollectionLiteralExpression node)
+        {
+            // PROTOTYPE: How should unconverted collection literals be handled?
+            return null;
+        }
+
         public override BoundNode VisitNewT(BoundNewT node)
         {
             VisitRvalue(node.InitializerExpressionOpt);
diff --git a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
index b67c0c9115a72..745a885cb3084 100644
--- a/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
+++ b/src/Compilers/CSharp/Portable/FlowAnalysis/NullableWalker.cs
@@ -3449,6 +3449,41 @@ protected override void VisitStatement(BoundStatement statement)
             return null;
         }
 
+        protected override void VisitCollectionLiteralExpression(BoundCollectionLiteralExpression node)
+        {
+            // PROTOTYPE: Do we need to call inferInitialObjectState() to set the initial state of the instance?
+            int containerSlot = GetOrCreatePlaceholderSlot(node);
+            bool delayCompletionForType = false; // PROTOTYPE: Should be true if the collection literal is target typed.
+
+            // PROTOTYPE: Test nullability of elements when the collection literal is target typed
+            // and the inferred target type has distinct element type nullability.
+            foreach (var initializer in node.Initializers)
+            {
+                switch (initializer)
+                {
+                    case BoundCollectionElementInitializer element:
+                        var completion = VisitCollectionElementInitializer(element, node.Type, delayCompletionForType);
+                        if (completion is { })
+                        {
+                            // PROTOTYPE: Complete the analysis later.
+                            completion(containerSlot, node.Type);
+                        }
+                        break;
+                    default:
+                        VisitRvalue(initializer);
+                        break;
+                }
+            }
+
+            SetResultType(node, TypeWithState.Create(node.Type, NullableFlowState.NotNull));
+        }
+
+        public override BoundNode? VisitUnconvertedCollectionLiteralExpression(BoundUnconvertedCollectionLiteralExpression node)
+        {
+            SetResultType(node, TypeWithState.Create(node.Type, NullableFlowState.NotNull));
+            return null;
+        }
+
         private void VisitObjectCreationExpressionBase(BoundObjectCreationExpressionBase node)
         {
             Debug.Assert(!IsConditionalState);
@@ -8031,6 +8066,7 @@ private TypeWithState VisitConversion(
                     break;
 
                 case ConversionKind.ObjectCreation:
+                case ConversionKind.CollectionLiteral:
                 case ConversionKind.SwitchExpression:
                 case ConversionKind.ConditionalExpression:
                     resultState = getConversionResultState(operandType);
diff --git a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
index efb758b5f0f8d..d0a65a076783b 100644
--- a/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
+++ b/src/Compilers/CSharp/Portable/Generated/BoundNodes.xml.Generated.cs
@@ -184,6 +184,9 @@ internal enum BoundKind : byte
         Attribute,
         UnconvertedObjectCreationExpression,
         ObjectCreationExpression,
+        UnconvertedCollectionLiteralExpression,
+        ArrayOrSpanCollectionLiteralExpression,
+        CollectionInitializerCollectionLiteralExpression,
         TupleLiteral,
         ConvertedTupleLiteral,
         DynamicObjectCreationExpression,
@@ -6274,6 +6277,122 @@ public BoundObjectCreationExpression Update(MethodSymbol constructor, ImmutableA
         }
     }
 
+    internal sealed partial class BoundUnconvertedCollectionLiteralExpression : BoundExpression
+    {
+        public BoundUnconvertedCollectionLiteralExpression(SyntaxNode syntax, ImmutableArray<BoundExpression> initializers, Binder binder, bool hasErrors = false)
+            : base(BoundKind.UnconvertedCollectionLiteralExpression, syntax, null, hasErrors || initializers.HasErrors())
+        {
+
+            RoslynDebug.Assert(!initializers.IsDefault, "Field 'initializers' cannot be null (use Null=\"allow\" in BoundNodes.xml to remove this check)");
+            RoslynDebug.Assert(binder is object, "Field 'binder' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+
+            this.Initializers = initializers;
+            this.Binder = binder;
+        }
+
+        public new TypeSymbol? Type => base.Type;
+        public ImmutableArray<BoundExpression> Initializers { get; }
+        public Binder Binder { get; }
+
+        [DebuggerStepThrough]
+        public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitUnconvertedCollectionLiteralExpression(this);
+
+        public BoundUnconvertedCollectionLiteralExpression Update(ImmutableArray<BoundExpression> initializers, Binder binder)
+        {
+            if (initializers != this.Initializers || binder != this.Binder)
+            {
+                var result = new BoundUnconvertedCollectionLiteralExpression(this.Syntax, initializers, binder, this.HasErrors);
+                result.CopyAttributes(this);
+                return result;
+            }
+            return this;
+        }
+    }
+
+    internal abstract partial class BoundCollectionLiteralExpression : BoundExpression
+    {
+        protected BoundCollectionLiteralExpression(BoundKind kind, SyntaxNode syntax, TypeSymbol? naturalTypeOpt, bool wasTargetTyped, BoundObjectOrCollectionValuePlaceholder placeholder, ImmutableArray<BoundExpression> initializers, TypeSymbol type, bool hasErrors = false)
+            : base(kind, syntax, type, hasErrors)
+        {
+
+            RoslynDebug.Assert(placeholder is object, "Field 'placeholder' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+            RoslynDebug.Assert(!initializers.IsDefault, "Field 'initializers' cannot be null (use Null=\"allow\" in BoundNodes.xml to remove this check)");
+            RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+
+            this.NaturalTypeOpt = naturalTypeOpt;
+            this.WasTargetTyped = wasTargetTyped;
+            this.Placeholder = placeholder;
+            this.Initializers = initializers;
+        }
+
+        public new TypeSymbol Type => base.Type!;
+        public TypeSymbol? NaturalTypeOpt { get; }
+        public bool WasTargetTyped { get; }
+        public BoundObjectOrCollectionValuePlaceholder Placeholder { get; }
+        public ImmutableArray<BoundExpression> Initializers { get; }
+    }
+
+    internal sealed partial class BoundArrayOrSpanCollectionLiteralExpression : BoundCollectionLiteralExpression
+    {
+        public BoundArrayOrSpanCollectionLiteralExpression(SyntaxNode syntax, MethodSymbol? spanConstructor, TypeSymbol? naturalTypeOpt, bool wasTargetTyped, BoundObjectOrCollectionValuePlaceholder placeholder, ImmutableArray<BoundExpression> initializers, TypeSymbol type, bool hasErrors = false)
+            : base(BoundKind.ArrayOrSpanCollectionLiteralExpression, syntax, naturalTypeOpt, wasTargetTyped, placeholder, initializers, type, hasErrors || placeholder.HasErrors() || initializers.HasErrors())
+        {
+
+            RoslynDebug.Assert(placeholder is object, "Field 'placeholder' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+            RoslynDebug.Assert(!initializers.IsDefault, "Field 'initializers' cannot be null (use Null=\"allow\" in BoundNodes.xml to remove this check)");
+            RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+
+            this.SpanConstructor = spanConstructor;
+        }
+
+        public MethodSymbol? SpanConstructor { get; }
+
+        [DebuggerStepThrough]
+        public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitArrayOrSpanCollectionLiteralExpression(this);
+
+        public BoundArrayOrSpanCollectionLiteralExpression Update(MethodSymbol? spanConstructor, TypeSymbol? naturalTypeOpt, bool wasTargetTyped, BoundObjectOrCollectionValuePlaceholder placeholder, ImmutableArray<BoundExpression> initializers, TypeSymbol type)
+        {
+            if (!Symbols.SymbolEqualityComparer.ConsiderEverything.Equals(spanConstructor, this.SpanConstructor) || !TypeSymbol.Equals(naturalTypeOpt, this.NaturalTypeOpt, TypeCompareKind.ConsiderEverything) || wasTargetTyped != this.WasTargetTyped || placeholder != this.Placeholder || initializers != this.Initializers || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
+            {
+                var result = new BoundArrayOrSpanCollectionLiteralExpression(this.Syntax, spanConstructor, naturalTypeOpt, wasTargetTyped, placeholder, initializers, type, this.HasErrors);
+                result.CopyAttributes(this);
+                return result;
+            }
+            return this;
+        }
+    }
+
+    internal sealed partial class BoundCollectionInitializerCollectionLiteralExpression : BoundCollectionLiteralExpression
+    {
+        public BoundCollectionInitializerCollectionLiteralExpression(SyntaxNode syntax, BoundExpression collectionCreation, TypeSymbol? naturalTypeOpt, bool wasTargetTyped, BoundObjectOrCollectionValuePlaceholder placeholder, ImmutableArray<BoundExpression> initializers, TypeSymbol type, bool hasErrors = false)
+            : base(BoundKind.CollectionInitializerCollectionLiteralExpression, syntax, naturalTypeOpt, wasTargetTyped, placeholder, initializers, type, hasErrors || collectionCreation.HasErrors() || placeholder.HasErrors() || initializers.HasErrors())
+        {
+
+            RoslynDebug.Assert(collectionCreation is object, "Field 'collectionCreation' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+            RoslynDebug.Assert(placeholder is object, "Field 'placeholder' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+            RoslynDebug.Assert(!initializers.IsDefault, "Field 'initializers' cannot be null (use Null=\"allow\" in BoundNodes.xml to remove this check)");
+            RoslynDebug.Assert(type is object, "Field 'type' cannot be null (make the type nullable in BoundNodes.xml to remove this check)");
+
+            this.CollectionCreation = collectionCreation;
+        }
+
+        public BoundExpression CollectionCreation { get; }
+
+        [DebuggerStepThrough]
+        public override BoundNode? Accept(BoundTreeVisitor visitor) => visitor.VisitCollectionInitializerCollectionLiteralExpression(this);
+
+        public BoundCollectionInitializerCollectionLiteralExpression Update(BoundExpression collectionCreation, TypeSymbol? naturalTypeOpt, bool wasTargetTyped, BoundObjectOrCollectionValuePlaceholder placeholder, ImmutableArray<BoundExpression> initializers, TypeSymbol type)
+        {
+            if (collectionCreation != this.CollectionCreation || !TypeSymbol.Equals(naturalTypeOpt, this.NaturalTypeOpt, TypeCompareKind.ConsiderEverything) || wasTargetTyped != this.WasTargetTyped || placeholder != this.Placeholder || initializers != this.Initializers || !TypeSymbol.Equals(type, this.Type, TypeCompareKind.ConsiderEverything))
+            {
+                var result = new BoundCollectionInitializerCollectionLiteralExpression(this.Syntax, collectionCreation, naturalTypeOpt, wasTargetTyped, placeholder, initializers, type, this.HasErrors);
+                result.CopyAttributes(this);
+                return result;
+            }
+            return this;
+        }
+    }
+
     internal abstract partial class BoundTupleExpression : BoundExpression
     {
         protected BoundTupleExpression(BoundKind kind, SyntaxNode syntax, ImmutableArray<BoundExpression> arguments, ImmutableArray<string?> argumentNamesOpt, ImmutableArray<bool> inferredNamesOpt, TypeSymbol? type, bool hasErrors = false)
@@ -8839,6 +8958,12 @@ internal R VisitInternal(BoundNode node, A arg)
                     return VisitUnconvertedObjectCreationExpression((BoundUnconvertedObjectCreationExpression)node, arg);
                 case BoundKind.ObjectCreationExpression:
                     return VisitObjectCreationExpression((BoundObjectCreationExpression)node, arg);
+                case BoundKind.UnconvertedCollectionLiteralExpression:
+                    return VisitUnconvertedCollectionLiteralExpression((BoundUnconvertedCollectionLiteralExpression)node, arg);
+                case BoundKind.ArrayOrSpanCollectionLiteralExpression:
+                    return VisitArrayOrSpanCollectionLiteralExpression((BoundArrayOrSpanCollectionLiteralExpression)node, arg);
+                case BoundKind.CollectionInitializerCollectionLiteralExpression:
+                    return VisitCollectionInitializerCollectionLiteralExpression((BoundCollectionInitializerCollectionLiteralExpression)node, arg);
                 case BoundKind.TupleLiteral:
                     return VisitTupleLiteral((BoundTupleLiteral)node, arg);
                 case BoundKind.ConvertedTupleLiteral:
@@ -9131,6 +9256,9 @@ internal abstract partial class BoundTreeVisitor<A, R>
         public virtual R VisitAttribute(BoundAttribute node, A arg) => this.DefaultVisit(node, arg);
         public virtual R VisitUnconvertedObjectCreationExpression(BoundUnconvertedObjectCreationExpression node, A arg) => this.DefaultVisit(node, arg);
         public virtual R VisitObjectCreationExpression(BoundObjectCreationExpression node, A arg) => this.DefaultVisit(node, arg);
+        public virtual R VisitUnconvertedCollectionLiteralExpression(BoundUnconvertedCollectionLiteralExpression node, A arg) => this.DefaultVisit(node, arg);
+        public virtual R VisitArrayOrSpanCollectionLiteralExpression(BoundArrayOrSpanCollectionLiteralExpression node, A arg) => this.DefaultVisit(node, arg);
+        public virtual R VisitCollectionInitializerCollectionLiteralExpression(BoundCollectionInitializerCollectionLiteralExpression node, A arg) => this.DefaultVisit(node, arg);
         public virtual R VisitTupleLiteral(BoundTupleLiteral node, A arg) => this.DefaultVisit(node, arg);
         public virtual R VisitConvertedTupleLiteral(BoundConvertedTupleLiteral node, A arg) => this.DefaultVisit(node, arg);
         public virtual R VisitDynamicObjectCreationExpression(BoundDynamicObjectCreationExpression node, A arg) => this.DefaultVisit(node, arg);
@@ -9359,6 +9487,9 @@ internal abstract partial class BoundTreeVisitor
         public virtual BoundNode? VisitAttribute(BoundAttribute node) => this.DefaultVisit(node);
         public virtual BoundNode? VisitUnconvertedObjectCreationExpression(BoundUnconvertedObjectCreationExpression node) => this.DefaultVisit(node);
         public virtual BoundNode? VisitObjectCreationExpression(BoundObjectCreationExpression node) => this.DefaultVisit(node);
+        public virtual BoundNode? VisitUnconvertedCollectionLiteralExpression(BoundUnconvertedCollectionLiteralExpression node) => this.DefaultVisit(node);
+        public virtual BoundNode? VisitArrayOrSpanCollectionLiteralExpression(BoundArrayOrSpanCollectionLiteralExpression node) => this.DefaultVisit(node);
+        public virtual BoundNode? VisitCollectionInitializerCollectionLiteralExpression(BoundCollectionInitializerCollectionLiteralExpression node) => this.DefaultVisit(node);
         public virtual BoundNode? VisitTupleLiteral(BoundTupleLiteral node) => this.DefaultVisit(node);
         public virtual BoundNode? VisitConvertedTupleLiteral(BoundConvertedTupleLiteral node) => this.DefaultVisit(node);
         public virtual BoundNode? VisitDynamicObjectCreationExpression(BoundDynamicObjectCreationExpression node) => this.DefaultVisit(node);
@@ -10127,6 +10258,21 @@ internal abstract partial class BoundTreeWalker : BoundTreeVisitor
             this.Visit(node.InitializerExpressionOpt);
             return null;
         }
+        public override BoundNode? VisitUnconvertedCollectionLiteralExpression(BoundUnconvertedCollectionLiteralExpression node)
+        {
+            this.VisitList(node.Initializers);
+            return null;
+        }
+        public override BoundNode? VisitArrayOrSpanCollectionLiteralExpression(BoundArrayOrSpanCollectionLiteralExpression node)
+        {
+            this.VisitList(node.Initializers);
+            return null;
+        }
+        public override BoundNode? VisitCollectionInitializerCollectionLiteralExpression(BoundCollectionInitializerCollectionLiteralExpression node)
+        {
+            this.VisitList(node.Initializers);
+            return null;
+        }
         public override BoundNode? VisitTupleLiteral(BoundTupleLiteral node)
         {
             this.VisitList(node.Arguments);
@@ -11373,6 +11519,29 @@ internal abstract partial class BoundTreeRewriter : BoundTreeVisitor
             TypeSymbol? type = this.VisitType(node.Type);
             return node.Update(node.Constructor, node.ConstructorsGroup, arguments, node.ArgumentNamesOpt, node.ArgumentRefKindsOpt, node.Expanded, node.ArgsToParamsOpt, node.DefaultArguments, node.ConstantValueOpt, initializerExpressionOpt, node.WasTargetTyped, type);
         }
+        public override BoundNode? VisitUnconvertedCollectionLiteralExpression(BoundUnconvertedCollectionLiteralExpression node)
+        {
+            ImmutableArray<BoundExpression> initializers = this.VisitList(node.Initializers);
+            TypeSymbol? type = this.VisitType(node.Type);
+            return node.Update(initializers, node.Binder);
+        }
+        public override BoundNode? VisitArrayOrSpanCollectionLiteralExpression(BoundArrayOrSpanCollectionLiteralExpression node)
+        {
+            BoundObjectOrCollectionValuePlaceholder placeholder = node.Placeholder;
+            ImmutableArray<BoundExpression> initializers = this.VisitList(node.Initializers);
+            TypeSymbol? naturalTypeOpt = this.VisitType(node.NaturalTypeOpt);
+            TypeSymbol? type = this.VisitType(node.Type);
+            return node.Update(node.SpanConstructor, naturalTypeOpt, node.WasTargetTyped, placeholder, initializers, type);
+        }
+        public override BoundNode? VisitCollectionInitializerCollectionLiteralExpression(BoundCollectionInitializerCollectionLiteralExpression node)
+        {
+            BoundExpression collectionCreation = node.CollectionCreation;
+            BoundObjectOrCollectionValuePlaceholder placeholder = node.Placeholder;
+            ImmutableArray<BoundExpression> initializers = this.VisitList(node.Initializers);
+            TypeSymbol? naturalTypeOpt = this.VisitType(node.NaturalTypeOpt);
+            TypeSymbol? type = this.VisitType(node.Type);
+            return node.Update(collectionCreation, naturalTypeOpt, node.WasTargetTyped, placeholder, initializers, type);
+        }
         public override BoundNode? VisitTupleLiteral(BoundTupleLiteral node)
         {
             ImmutableArray<BoundExpression> arguments = this.VisitList(node.Arguments);
@@ -13553,6 +13722,63 @@ public NullabilityRewriter(ImmutableDictionary<BoundExpression, (NullabilityInfo
             return updatedNode;
         }
 
+        public override BoundNode? VisitUnconvertedCollectionLiteralExpression(BoundUnconvertedCollectionLiteralExpression node)
+        {
+            ImmutableArray<BoundExpression> initializers = this.VisitList(node.Initializers);
+            BoundUnconvertedCollectionLiteralExpression updatedNode;
+
+            if (_updatedNullabilities.TryGetValue(node, out (NullabilityInfo Info, TypeSymbol? Type) infoAndType))
+            {
+                updatedNode = node.Update(initializers, node.Binder);
+                updatedNode.TopLevelNullability = infoAndType.Info;
+            }
+            else
+            {
+                updatedNode = node.Update(initializers, node.Binder);
+            }
+            return updatedNode;
+        }
+
+        public override BoundNode? VisitArrayOrSpanCollectionLiteralExpression(BoundArrayOrSpanCollectionLiteralExpression node)
+        {
+            MethodSymbol? spanConstructor = GetUpdatedSymbol(node, node.SpanConstructor);
+            TypeSymbol? naturalTypeOpt = GetUpdatedSymbol(node, node.NaturalTypeOpt);
+            BoundObjectOrCollectionValuePlaceholder placeholder = node.Placeholder;
+            ImmutableArray<BoundExpression> initializers = this.VisitList(node.Initializers);
+            BoundArrayOrSpanCollectionLiteralExpression updatedNode;
+
+            if (_updatedNullabilities.TryGetValue(node, out (NullabilityInfo Info, TypeSymbol? Type) infoAndType))
+            {
+                updatedNode = node.Update(spanConstructor, naturalTypeOpt, node.WasTargetTyped, placeholder, initializers, infoAndType.Type!);
+                updatedNode.TopLevelNullability = infoAndType.Info;
+            }
+            else
+            {
+                updatedNode = node.Update(spanConstructor, naturalTypeOpt, node.WasTargetTyped, placeholder, initializers, node.Type);
+            }
+            return updatedNode;
+        }
+
+        public override BoundNode? VisitCollectionInitializerCollectionLiteralExpression(BoundCollectionInitializerCollectionLiteralExpression node)
+        {
+            TypeSymbol? naturalTypeOpt = GetUpdatedSymbol(node, node.NaturalTypeOpt);
+            BoundExpression collectionCreation = node.CollectionCreation;
+            BoundObjectOrCollectionValuePlaceholder placeholder = node.Placeholder;
+            ImmutableArray<BoundExpression> initializers = this.VisitList(node.Initializers);
+            BoundCollectionInitializerCollectionLiteralExpression updatedNode;
+
+            if (_updatedNullabilities.TryGetValue(node, out (NullabilityInfo Info, TypeSymbol? Type) infoAndType))
+            {
+                updatedNode = node.Update(collectionCreation, naturalTypeOpt, node.WasTargetTyped, placeholder, initializers, infoAndType.Type!);
+                updatedNode.TopLevelNullability = infoAndType.Info;
+            }
+            else
+            {
+                updatedNode = node.Update(collectionCreation, naturalTypeOpt, node.WasTargetTyped, placeholder, initializers, node.Type);
+            }
+            return updatedNode;
+        }
+
         public override BoundNode? VisitTupleLiteral(BoundTupleLiteral node)
         {
             ImmutableArray<BoundExpression> arguments = this.VisitList(node.Arguments);
@@ -15896,6 +16122,39 @@ private BoundTreeDumperNodeProducer()
             new TreeDumperNode("hasErrors", node.HasErrors, null)
         }
         );
+        public override TreeDumperNode VisitUnconvertedCollectionLiteralExpression(BoundUnconvertedCollectionLiteralExpression node, object? arg) => new TreeDumperNode("unconvertedCollectionLiteralExpression", null, new TreeDumperNode[]
+        {
+            new TreeDumperNode("initializers", null, from x in node.Initializers select Visit(x, null)),
+            new TreeDumperNode("binder", node.Binder, null),
+            new TreeDumperNode("type", node.Type, null),
+            new TreeDumperNode("isSuppressed", node.IsSuppressed, null),
+            new TreeDumperNode("hasErrors", node.HasErrors, null)
+        }
+        );
+        public override TreeDumperNode VisitArrayOrSpanCollectionLiteralExpression(BoundArrayOrSpanCollectionLiteralExpression node, object? arg) => new TreeDumperNode("arrayOrSpanCollectionLiteralExpression", null, new TreeDumperNode[]
+        {
+            new TreeDumperNode("spanConstructor", node.SpanConstructor, null),
+            new TreeDumperNode("naturalTypeOpt", node.NaturalTypeOpt, null),
+            new TreeDumperNode("wasTargetTyped", node.WasTargetTyped, null),
+            new TreeDumperNode("placeholder", null, new TreeDumperNode[] { Visit(node.Placeholder, null) }),
+            new TreeDumperNode("initializers", null, from x in node.Initializers select Visit(x, null)),
+            new TreeDumperNode("type", node.Type, null),
+            new TreeDumperNode("isSuppressed", node.IsSuppressed, null),
+            new TreeDumperNode("hasErrors", node.HasErrors, null)
+        }
+        );
+        public override TreeDumperNode VisitCollectionInitializerCollectionLiteralExpression(BoundCollectionInitializerCollectionLiteralExpression node, object? arg) => new TreeDumperNode("collectionInitializerCollectionLiteralExpression", null, new TreeDumperNode[]
+        {
+            new TreeDumperNode("collectionCreation", null, new TreeDumperNode[] { Visit(node.CollectionCreation, null) }),
+            new TreeDumperNode("naturalTypeOpt", node.NaturalTypeOpt, null),
+            new TreeDumperNode("wasTargetTyped", node.WasTargetTyped, null),
+            new TreeDumperNode("placeholder", null, new TreeDumperNode[] { Visit(node.Placeholder, null) }),
+            new TreeDumperNode("initializers", null, from x in node.Initializers select Visit(x, null)),
+            new TreeDumperNode("type", node.Type, null),
+            new TreeDumperNode("isSuppressed", node.IsSuppressed, null),
+            new TreeDumperNode("hasErrors", node.HasErrors, null)
+        }
+        );
         public override TreeDumperNode VisitTupleLiteral(BoundTupleLiteral node, object? arg) => new TreeDumperNode("tupleLiteral", null, new TreeDumperNode[]
         {
             new TreeDumperNode("arguments", null, from x in node.Arguments select Visit(x, null)),
diff --git a/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_ExpressionTrees.cs b/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_ExpressionTrees.cs
index 4e12cc426d91b..006b40dd69564 100644
--- a/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_ExpressionTrees.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/DiagnosticsPass_ExpressionTrees.cs
@@ -981,5 +981,25 @@ public override BoundNode VisitFunctionPointerInvocation(BoundFunctionPointerInv
 
             return base.VisitFunctionPointerInvocation(node);
         }
+
+        public override BoundNode VisitArrayOrSpanCollectionLiteralExpression(BoundArrayOrSpanCollectionLiteralExpression node)
+        {
+            CheckCollectionLiteralExpression(node);
+            return base.VisitArrayOrSpanCollectionLiteralExpression(node);
+        }
+
+        public override BoundNode VisitCollectionInitializerCollectionLiteralExpression(BoundCollectionInitializerCollectionLiteralExpression node)
+        {
+            CheckCollectionLiteralExpression(node);
+            return base.VisitCollectionInitializerCollectionLiteralExpression(node);
+        }
+
+        private void CheckCollectionLiteralExpression(BoundCollectionLiteralExpression node)
+        {
+            if (_inExpressionLambda)
+            {
+                Error(ErrorCode.ERR_ExpressionTreeContainsCollectionLiteral, node);
+            }
+        }
     }
 }
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionLiteral.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionLiteral.cs
new file mode 100644
index 0000000000000..0b0a9a8d99dfe
--- /dev/null
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_CollectionLiteral.cs
@@ -0,0 +1,100 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Collections.Immutable;
+using System.Diagnostics;
+using Microsoft.CodeAnalysis.CSharp.Symbols;
+using Microsoft.CodeAnalysis.PooledObjects;
+using Roslyn.Utilities;
+
+namespace Microsoft.CodeAnalysis.CSharp
+{
+    internal sealed partial class LocalRewriter
+    {
+        public override BoundNode? VisitArrayOrSpanCollectionLiteralExpression(BoundArrayOrSpanCollectionLiteralExpression node)
+        {
+            Debug.Assert(!_inExpressionLambda);
+            Debug.Assert(node.Type is { });
+
+            var syntax = node.Syntax;
+            var collectionType = node.Type;
+            var spanConstructor = node.SpanConstructor;
+
+            var arrayType = collectionType as ArrayTypeSymbol;
+            if (arrayType is null)
+            {
+                Debug.Assert(spanConstructor is { });
+                Debug.Assert(TypeSymbol.Equals(collectionType, spanConstructor.ContainingType, TypeCompareKind.AllIgnoreOptions));
+
+                var elementType = ((NamedTypeSymbol)collectionType).TypeArgumentsWithAnnotationsNoUseSiteDiagnostics[0];
+                arrayType = ArrayTypeSymbol.CreateSZArray(_compilation.Assembly, elementType);
+            }
+
+            var initializers = node.Initializers;
+            int arrayLength = initializers.Length;
+            // PROTOTYPE: Should [] be emitted as Array.Empty<T>()?
+            var initialization = (arrayLength == 0)
+                ? null
+                : new BoundArrayInitialization(
+                    syntax,
+                    isInferred: false,
+                    initializers.SelectAsArray(e => VisitExpression(e)));
+            var array = new BoundArrayCreation(
+                syntax,
+                ImmutableArray.Create<BoundExpression>(
+                    new BoundLiteral(
+                        syntax,
+                        ConstantValue.Create(arrayLength),
+                        _compilation.GetSpecialType(SpecialType.System_Int32))),
+                initialization,
+                arrayType)
+            { WasCompilerGenerated = true };
+
+            if (spanConstructor is null)
+            {
+                return array;
+            }
+
+            Debug.Assert(TypeSymbol.Equals(array.Type, spanConstructor.Parameters[0].Type, TypeCompareKind.AllIgnoreOptions));
+            return new BoundObjectCreationExpression(syntax, spanConstructor, array);
+        }
+
+        public override BoundNode? VisitCollectionInitializerCollectionLiteralExpression(BoundCollectionInitializerCollectionLiteralExpression node)
+        {
+            Debug.Assert(!_inExpressionLambda);
+            Debug.Assert(node.Type is { });
+
+            var rewrittenReceiver = VisitExpression(node.CollectionCreation);
+
+            // Create a temp for the collection.
+            BoundAssignmentOperator assignmentToTemp;
+            BoundLocal temp = _factory.StoreToTemp(rewrittenReceiver, out assignmentToTemp, isKnownToReferToTempIfReferenceType: true);
+            var initializers = node.Initializers;
+            var sideEffects = ArrayBuilder<BoundExpression>.GetInstance(initializers.Length + 1);
+            sideEffects.Add(assignmentToTemp);
+
+            AddPlaceholderReplacement(node.Placeholder, temp);
+
+            foreach (var initializer in initializers)
+            {
+                var rewrittenInitializer = initializer is BoundCollectionElementInitializer element
+                    ? MakeCollectionInitializer(temp, element)
+                    : throw ExceptionUtilities.UnexpectedValue(initializer.Kind);
+                if (rewrittenInitializer != null)
+                {
+                    sideEffects.Add(rewrittenInitializer);
+                }
+            }
+
+            RemovePlaceholderReplacement(node.Placeholder);
+
+            return new BoundSequence(
+                node.Syntax,
+                ImmutableArray.Create(temp.LocalSymbol),
+                sideEffects.ToImmutableAndFree(),
+                temp,
+                node.Type);
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
index 1f12ef11e88d9..1bc4ef676c28b 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
@@ -57,6 +57,11 @@ public override BoundNode VisitConversion(BoundConversion node)
                                                  BoundDelegateCreationExpression { WasTargetTyped: true });
 
                     return objectCreation;
+
+                case ConversionKind.CollectionLiteral:
+                    // Skip through target-typed collection literals
+                    Debug.Assert(node.Type.Equals(node.Operand.Type, TypeCompareKind.AllIgnoreOptions));
+                    return VisitExpression(node.Operand)!;
             }
 
             var rewrittenType = VisitType(node.Type);
diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectOrCollectionInitializerExpression.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectOrCollectionInitializerExpression.cs
index 121bc92182a8a..4dc2b30997aa9 100644
--- a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectOrCollectionInitializerExpression.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_ObjectOrCollectionInitializerExpression.cs
@@ -136,7 +136,7 @@ private BoundExpression MakeDynamicCollectionInitializer(BoundExpression rewritt
         }
 
         // Rewrite collection initializer element Add method call:
-        //  new List<int> { 1, 2, 3 };  OR  new List<int> { { 1, 2 }, 3 };
+        //  new List<int> { 1, 2, 3 };  OR  new List<int> { { 1, 2 }, 3 }; OR [1, 2, 3]
         //                  ~                               ~~~~~~~~
         private BoundExpression? MakeCollectionInitializer(BoundExpression? rewrittenReceiver, BoundCollectionElementInitializer initializer)
         {
diff --git a/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs b/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs
index be08becf4ceca..e27960f32c222 100644
--- a/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs
+++ b/src/Compilers/CSharp/Portable/Operations/CSharpOperationFactory.cs
@@ -100,6 +100,12 @@ public CSharpOperationFactory(SemanticModel semanticModel)
                     return CreateBoundArrayCreationOperation((BoundArrayCreation)boundNode);
                 case BoundKind.ArrayInitialization:
                     return CreateBoundArrayInitializationOperation((BoundArrayInitialization)boundNode);
+                case BoundKind.CollectionInitializerCollectionLiteralExpression:
+                    return CreateBoundCollectionInitializerCollectionLiteralExpression((BoundCollectionInitializerCollectionLiteralExpression)boundNode);
+                case BoundKind.ArrayOrSpanCollectionLiteralExpression:
+                    return CreateBoundArrayOrSpanCollectionLiteralExpression((BoundArrayOrSpanCollectionLiteralExpression)boundNode);
+                case BoundKind.UnconvertedCollectionLiteralExpression:
+                    return CreateBoundUnconvertedCollectionLiteralExpression((BoundUnconvertedCollectionLiteralExpression)boundNode);
                 case BoundKind.DefaultLiteral:
                     return CreateBoundDefaultLiteralOperation((BoundDefaultLiteral)boundNode);
                 case BoundKind.DefaultExpression:
@@ -1214,6 +1220,109 @@ private IArrayInitializerOperation CreateBoundArrayInitializationOperation(Bound
             return new ArrayInitializerOperation(elementValues, _semanticModel, syntax, isImplicit);
         }
 
+        // PROTOTYPE: Decide public API shape.
+        private IOperation CreateBoundArrayOrSpanCollectionLiteralExpression(BoundArrayOrSpanCollectionLiteralExpression boundCollectionLiteralExpression)
+        {
+            SyntaxNode syntax = boundCollectionLiteralExpression.Syntax;
+            ITypeSymbol? collectionType = boundCollectionLiteralExpression.GetPublicTypeSymbol();
+            bool isImplicit = boundCollectionLiteralExpression.WasCompilerGenerated;
+            var spanConstructor = boundCollectionLiteralExpression.SpanConstructor.GetPublicSymbol();
+            var initializer = new ArrayInitializerOperation(
+                CreateFromArray<BoundExpression, IOperation>(boundCollectionLiteralExpression.Initializers),
+                _semanticModel,
+                syntax,
+                isImplicit: true);
+            ImmutableArray<IOperation> dimensionSizes = ImmutableArray.Create<IOperation>(new LiteralOperation(
+                _semanticModel,
+                syntax,
+                _semanticModel.Compilation.GetSpecialType(SpecialType.System_Int32),
+                ConstantValue.Create(boundCollectionLiteralExpression.Initializers.Length),
+                isImplicit: true));
+            if (spanConstructor is null)
+            {
+                return new ArrayCreationOperation(
+                    dimensionSizes,
+                    initializer,
+                    _semanticModel,
+                    syntax,
+                    collectionType,
+                    isImplicit: isImplicit);
+            }
+            else
+            {
+                // PROTOTYPE: Decide public API shape. Will we always initialize the span
+                // with an array, and is it reasonable to expose this in the IOperation?
+                var array = new ArrayCreationOperation(
+                    dimensionSizes,
+                    initializer,
+                    _semanticModel,
+                    syntax,
+                    spanConstructor.Parameters[0].Type,
+                    isImplicit: true);
+                IArgumentOperation constructorArgument = new ArgumentOperation(
+                    ArgumentKind.Explicit,
+                    spanConstructor.Parameters[0],
+                    array,
+                    OperationFactory.IdentityConversion,
+                    OperationFactory.IdentityConversion,
+                    _semanticModel,
+                    syntax,
+                    isImplicit: true);
+                return new ObjectCreationOperation(
+                    spanConstructor,
+                    initializer: null,
+                    ImmutableArray.Create(constructorArgument),
+                    _semanticModel,
+                    syntax,
+                    collectionType,
+                    constantValue: null,
+                    isImplicit);
+            }
+        }
+
+        private IOperation CreateBoundCollectionInitializerCollectionLiteralExpression(BoundCollectionInitializerCollectionLiteralExpression boundCollectionLiteralExpression)
+        {
+            SyntaxNode syntax = boundCollectionLiteralExpression.Syntax;
+            ITypeSymbol? collectionType = boundCollectionLiteralExpression.GetPublicTypeSymbol();
+            bool isImplicit = boundCollectionLiteralExpression.WasCompilerGenerated;
+            var initializer = new ObjectOrCollectionInitializerOperation(
+                CreateFromArray<BoundExpression, IOperation>(boundCollectionLiteralExpression.Initializers),
+                _semanticModel,
+                syntax,
+                collectionType,
+                isImplicit: true);
+            if (collectionType is ITypeParameterSymbol)
+            {
+                return new TypeParameterObjectCreationOperation(initializer, _semanticModel, syntax, collectionType, isImplicit: isImplicit);
+            }
+            else if (boundCollectionLiteralExpression.CollectionCreation is BoundObjectCreationExpression collectionCreation)
+            {
+                return new ObjectCreationOperation(
+                    collectionCreation.Constructor.GetPublicSymbol(),
+                    initializer,
+                    DeriveArguments(collectionCreation),
+                    _semanticModel,
+                    syntax,
+                    collectionType,
+                    constantValue: null,
+                    isImplicit: isImplicit);
+            }
+            else
+            {
+                // PROTOTYPE: Temporary until natural type is supported.
+                return new InvalidOperation(ImmutableArray.Create<IOperation>(initializer), _semanticModel, syntax, collectionType, constantValue: null, isImplicit);
+            }
+        }
+
+        private IOperation CreateBoundUnconvertedCollectionLiteralExpression(BoundUnconvertedCollectionLiteralExpression boundCollectionLiteralExpression)
+        {
+            SyntaxNode syntax = boundCollectionLiteralExpression.Syntax;
+            ITypeSymbol? collectionType = boundCollectionLiteralExpression.GetPublicTypeSymbol();
+            bool isImplicit = boundCollectionLiteralExpression.WasCompilerGenerated;
+            var children = CreateFromArray<BoundExpression, IOperation>(boundCollectionLiteralExpression.Initializers);
+            return new InvalidOperation(children, _semanticModel, syntax, collectionType, constantValue: null, isImplicit);
+        }
+
         private IDefaultValueOperation CreateBoundDefaultLiteralOperation(BoundDefaultLiteral boundDefaultLiteral)
         {
             SyntaxNode syntax = boundDefaultLiteral.Syntax;
diff --git a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
index 834f352f6e43a..835c5a183d3d0 100644
--- a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
+++ b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt
@@ -1,4 +1,5 @@
 *REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.UsingDirectiveSyntax.Name.get -> Microsoft.CodeAnalysis.CSharp.Syntax.NameSyntax!
+Microsoft.CodeAnalysis.CSharp.Conversion.IsCollectionLiteral.get -> bool
 Microsoft.CodeAnalysis.CSharp.Syntax.CollectionCreationExpressionSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.CollectionCreationExpressionSyntax.AddElements(params Microsoft.CodeAnalysis.CSharp.Syntax.CollectionElementSyntax![]! items) -> Microsoft.CodeAnalysis.CSharp.Syntax.CollectionCreationExpressionSyntax!
 Microsoft.CodeAnalysis.CSharp.Syntax.CollectionCreationExpressionSyntax.CloseBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken
diff --git a/src/Compilers/CSharp/Portable/Symbols/ErrorTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/ErrorTypeSymbol.cs
index 230869b1083c1..68482459eda9e 100644
--- a/src/Compilers/CSharp/Portable/Symbols/ErrorTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/ErrorTypeSymbol.cs
@@ -291,7 +291,7 @@ public override string Name
 
         /// <summary>
         /// Returns the type arguments that have been substituted for the type parameters. 
-        /// If nothing has been substituted for a give type parameters,
+        /// If nothing has been substituted for a given type parameter,
         /// then the type parameter itself is consider the type argument.
         /// </summary>
         internal override ImmutableArray<TypeWithAnnotations> TypeArgumentsWithAnnotationsNoUseSiteDiagnostics
diff --git a/src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs
index d75511e785189..79b732e629c21 100644
--- a/src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs
+++ b/src/Compilers/CSharp/Portable/Symbols/NamedTypeSymbol.cs
@@ -64,7 +64,7 @@ internal NamedTypeSymbol(TupleExtraData tupleData = null)
 
         /// <summary>
         /// Returns the type arguments that have been substituted for the type parameters. 
-        /// If nothing has been substituted for a give type parameters,
+        /// If nothing has been substituted for a given type parameter,
         /// then the type parameter itself is consider the type argument.
         /// </summary>
         internal abstract ImmutableArray<TypeWithAnnotations> TypeArgumentsWithAnnotationsNoUseSiteDiagnostics { get; }
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
index 80a11921ae2eb..6e37b9e09193f 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf
@@ -382,6 +382,16 @@
         <target state="translated">{0} neimplementuje člen rozhraní {1}. {2} nemůže implementovat {1}.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralElementNotImplemented">
+        <source>Support for collection literal dictionary and spread elements has not been implemented.</source>
+        <target state="new">Support for collection literal dictionary and spread elements has not been implemented.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralTargetTypeNotConstructible">
+        <source>Cannot initialize type '{0}' with a collection literal because the type is not constructible.</source>
+        <target state="new">Cannot initialize type '{0}' with a collection literal because the type is not constructible.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ConWithUnmanagedCon">
         <source>Type parameter '{1}' has the 'unmanaged' constraint so '{1}' cannot be used as a constraint for '{0}'</source>
         <target state="translated">Parametr typu {1} má omezení unmanaged, takže není možné používat {1} jako omezení pro {0}.</target>
@@ -557,6 +567,11 @@
         <target state="translated">Strom výrazů nesmí obsahovat přístup statického virtuálního člena nebo člena abstraktního rozhraní.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsCollectionLiteral">
+        <source>An expression tree may not contain a collection literal.</source>
+        <target state="new">An expression tree may not contain a collection literal.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">Strom výrazů nesmí obsahovat výraz indexu od-do (^).</target>
@@ -1832,6 +1847,11 @@
         <target state="translated">zaškrtnuté uživatelem definované operátory</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureCollectionLiterals">
+        <source>collection literals</source>
+        <target state="new">collection literals</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">kovariantní návratové hodnoty</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
index 906893fa08255..f39e734ac4ca6 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf
@@ -382,6 +382,16 @@
         <target state="translated">Der Schnittstellenmember "{1}" wird von "{0}" nicht implementiert. "{1}" kann von "{2}" nicht implementiert werden.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralElementNotImplemented">
+        <source>Support for collection literal dictionary and spread elements has not been implemented.</source>
+        <target state="new">Support for collection literal dictionary and spread elements has not been implemented.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralTargetTypeNotConstructible">
+        <source>Cannot initialize type '{0}' with a collection literal because the type is not constructible.</source>
+        <target state="new">Cannot initialize type '{0}' with a collection literal because the type is not constructible.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ConWithUnmanagedCon">
         <source>Type parameter '{1}' has the 'unmanaged' constraint so '{1}' cannot be used as a constraint for '{0}'</source>
         <target state="translated">Der {1}-Typparameter enthält die Einschränkung "unmanaged". "{1}" kann daher nicht als Einschränkung für "{0}" verwendet werden.</target>
@@ -557,6 +567,11 @@
         <target state="translated">Eine Ausdrucksbaumstruktur darf keinen Zugriff auf einen statischen virtuellen oder abstrakten Schnittstellenmember enthalten.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsCollectionLiteral">
+        <source>An expression tree may not contain a collection literal.</source>
+        <target state="new">An expression tree may not contain a collection literal.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">Eine Ausdrucksbaumstruktur darf keinen vom Ende ausgehenden Indexausdruck ("^") enthalten.</target>
@@ -1832,6 +1847,11 @@
         <target state="translated">Überprüfte benutzerdefinierte Operatoren</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureCollectionLiterals">
+        <source>collection literals</source>
+        <target state="new">collection literals</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">Covariante Rückgaben</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
index dc9dd51f1da34..4dcb205282aed 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf
@@ -382,6 +382,16 @@
         <target state="translated">"{0}" no implementa el miembro de interfaz "{1}". "{2}" no puede implementar "{1}".</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralElementNotImplemented">
+        <source>Support for collection literal dictionary and spread elements has not been implemented.</source>
+        <target state="new">Support for collection literal dictionary and spread elements has not been implemented.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralTargetTypeNotConstructible">
+        <source>Cannot initialize type '{0}' with a collection literal because the type is not constructible.</source>
+        <target state="new">Cannot initialize type '{0}' with a collection literal because the type is not constructible.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ConWithUnmanagedCon">
         <source>Type parameter '{1}' has the 'unmanaged' constraint so '{1}' cannot be used as a constraint for '{0}'</source>
         <target state="translated">El parámetro de tipo "{1}" tiene la restricción "unmanaged"; por tanto, "{1}" no se puede usar como restricción para "{0}"</target>
@@ -557,6 +567,11 @@
         <target state="translated">Un árbol de (la) expresión no puede contener un acceso de miembro de interfaz abstracta o virtual estática</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsCollectionLiteral">
+        <source>An expression tree may not contain a collection literal.</source>
+        <target state="new">An expression tree may not contain a collection literal.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">Un árbol de expresión no puede contener una expresión de índice del otro extremo ("^").</target>
@@ -1832,6 +1847,11 @@
         <target state="translated">operadores definidos por el usuario comprobados</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureCollectionLiterals">
+        <source>collection literals</source>
+        <target state="new">collection literals</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">valores devueltos de covariante</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
index b89ac60855d18..83805ce68ee62 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf
@@ -382,6 +382,16 @@
         <target state="translated">'{0}' n'implémente pas le membre d'interface '{1}'. '{2}' ne peut pas implémenter '{1}'.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralElementNotImplemented">
+        <source>Support for collection literal dictionary and spread elements has not been implemented.</source>
+        <target state="new">Support for collection literal dictionary and spread elements has not been implemented.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralTargetTypeNotConstructible">
+        <source>Cannot initialize type '{0}' with a collection literal because the type is not constructible.</source>
+        <target state="new">Cannot initialize type '{0}' with a collection literal because the type is not constructible.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ConWithUnmanagedCon">
         <source>Type parameter '{1}' has the 'unmanaged' constraint so '{1}' cannot be used as a constraint for '{0}'</source>
         <target state="translated">Le paramètre de type '{1}' a la contrainte 'unmanaged'. '{1}' ne peut donc pas être utilisé comme contrainte pour '{0}'</target>
@@ -557,6 +567,11 @@
         <target state="translated">Une arborescence d’expressions ne peut pas contenir d’accès à un membre d’interface virtuelle ou abstraite statique</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsCollectionLiteral">
+        <source>An expression tree may not contain a collection literal.</source>
+        <target state="new">An expression tree may not contain a collection literal.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">Une arborescence de l'expression ne peut pas contenir d'expression d'index partant de la fin ('^').</target>
@@ -1832,6 +1847,11 @@
         <target state="translated">opérateurs définis par l’utilisateur vérifiés</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureCollectionLiterals">
+        <source>collection literals</source>
+        <target state="new">collection literals</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">retours covariants</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
index 3432fc126d1a8..b3c68f7a01c9f 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf
@@ -382,6 +382,16 @@
         <target state="translated">'{0}' non implementa il membro di interfaccia '{1}'. '{2}' non può implementare '{1}'.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralElementNotImplemented">
+        <source>Support for collection literal dictionary and spread elements has not been implemented.</source>
+        <target state="new">Support for collection literal dictionary and spread elements has not been implemented.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralTargetTypeNotConstructible">
+        <source>Cannot initialize type '{0}' with a collection literal because the type is not constructible.</source>
+        <target state="new">Cannot initialize type '{0}' with a collection literal because the type is not constructible.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ConWithUnmanagedCon">
         <source>Type parameter '{1}' has the 'unmanaged' constraint so '{1}' cannot be used as a constraint for '{0}'</source>
         <target state="translated">Il parametro di tipo '{1}' ha il vincolo 'managed'. Non è quindi possibile usare '{1}' come vincolo per '{0}'</target>
@@ -557,6 +567,11 @@
         <target state="translated">Un albero delle espressioni può non contenere un accesso del membro di interfaccia statico astratto o virtuale</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsCollectionLiteral">
+        <source>An expression tree may not contain a collection literal.</source>
+        <target state="new">An expression tree may not contain a collection literal.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">Un albero delle espressioni non può contenere un'espressione di indice from end ('^').</target>
@@ -1832,6 +1847,11 @@
         <target state="translated">operatori definiti dall'utente controllati</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureCollectionLiterals">
+        <source>collection literals</source>
+        <target state="new">collection literals</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">tipi restituiti covarianti</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
index 9c56398a45af8..cb4b508127c84 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf
@@ -382,6 +382,16 @@
         <target state="translated">'{0}' は、インターフェイス メンバー '{1}' を実装していません。'{2}' は '{1}' を実装できません。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralElementNotImplemented">
+        <source>Support for collection literal dictionary and spread elements has not been implemented.</source>
+        <target state="new">Support for collection literal dictionary and spread elements has not been implemented.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralTargetTypeNotConstructible">
+        <source>Cannot initialize type '{0}' with a collection literal because the type is not constructible.</source>
+        <target state="new">Cannot initialize type '{0}' with a collection literal because the type is not constructible.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ConWithUnmanagedCon">
         <source>Type parameter '{1}' has the 'unmanaged' constraint so '{1}' cannot be used as a constraint for '{0}'</source>
         <target state="translated">型パラメーター '{1}' は 'unmanaged' 制約を含むので、'{0}' の制約として '{1}' を使用することはできません</target>
@@ -557,6 +567,11 @@
         <target state="translated">式ツリーに静的仮想または抽象インターフェイス メンバーへのアクセス権を含めることはできません</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsCollectionLiteral">
+        <source>An expression tree may not contain a collection literal.</source>
+        <target state="new">An expression tree may not contain a collection literal.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">式ツリーに、from-end インデックス ('^') 式を含めることはできません。</target>
@@ -1832,6 +1847,11 @@
         <target state="translated">チェックされたユーザー定義演算子</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureCollectionLiterals">
+        <source>collection literals</source>
+        <target state="new">collection literals</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">covariant の戻り値</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
index c00f566827726..f3ab074749c37 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf
@@ -382,6 +382,16 @@
         <target state="translated">'{0}'은(는) 인터페이스 멤버 '{1}'을(를) 구현하지 않습니다. '{2}'은(는) '{1}'을(를) 구현할 수 없습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralElementNotImplemented">
+        <source>Support for collection literal dictionary and spread elements has not been implemented.</source>
+        <target state="new">Support for collection literal dictionary and spread elements has not been implemented.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralTargetTypeNotConstructible">
+        <source>Cannot initialize type '{0}' with a collection literal because the type is not constructible.</source>
+        <target state="new">Cannot initialize type '{0}' with a collection literal because the type is not constructible.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ConWithUnmanagedCon">
         <source>Type parameter '{1}' has the 'unmanaged' constraint so '{1}' cannot be used as a constraint for '{0}'</source>
         <target state="translated">형식 매개 변수 '{1}'에 'unmanaged' 제약 조건이 있으므로 '{1}'은(는) '{0}'에 대한 제약 조건으로 사용할 수 없습니다.</target>
@@ -557,6 +567,11 @@
         <target state="translated">식 트리는 정적 가상 또는 추상 인터페이스 구성원에 대한 액세스를 포함할 수 없습니다.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsCollectionLiteral">
+        <source>An expression tree may not contain a collection literal.</source>
+        <target state="new">An expression tree may not contain a collection literal.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">식 트리에는 내림차순 인덱스('^') 식을 포함할 수 없습니다.</target>
@@ -1832,6 +1847,11 @@
         <target state="translated">확인된 사용자 정의 연산자</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureCollectionLiterals">
+        <source>collection literals</source>
+        <target state="new">collection literals</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">공변(covariant) 반환</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
index edb7c113e1670..bcc80eff82ab8 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf
@@ -382,6 +382,16 @@
         <target state="translated">Element „{0}” nie implementuje składowej interfejsu „{1}”. Element „{2}” nie może implementować elementu „{1}”.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralElementNotImplemented">
+        <source>Support for collection literal dictionary and spread elements has not been implemented.</source>
+        <target state="new">Support for collection literal dictionary and spread elements has not been implemented.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralTargetTypeNotConstructible">
+        <source>Cannot initialize type '{0}' with a collection literal because the type is not constructible.</source>
+        <target state="new">Cannot initialize type '{0}' with a collection literal because the type is not constructible.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ConWithUnmanagedCon">
         <source>Type parameter '{1}' has the 'unmanaged' constraint so '{1}' cannot be used as a constraint for '{0}'</source>
         <target state="translated">Parametr typu „{1}” ma ograniczenie „unmanaged”, dlatego elementu „{1}” nie można użyć jako ograniczenia dla elementu „{0}”</target>
@@ -557,6 +567,11 @@
         <target state="translated">Drzewo wyrażenia nie może zawierać dostępu do statycznej składowej abstrakcyjnej lub wirtualnej w interfejsie</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsCollectionLiteral">
+        <source>An expression tree may not contain a collection literal.</source>
+        <target state="new">An expression tree may not contain a collection literal.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">Drzewo wyrażeń nie może zawierać wyrażenia „od końca indeksu” („^”).</target>
@@ -1832,6 +1847,11 @@
         <target state="translated">zaznaczone operatory zdefiniowane przez użytkownika</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureCollectionLiterals">
+        <source>collection literals</source>
+        <target state="new">collection literals</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">zwroty kowariantne</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
index b3b22523740c1..c2286c06930e8 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf
@@ -382,6 +382,16 @@
         <target state="translated">'{0}' não implementa o membro de interface '{1}'. '{2}' não pode implementar '{1}'.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralElementNotImplemented">
+        <source>Support for collection literal dictionary and spread elements has not been implemented.</source>
+        <target state="new">Support for collection literal dictionary and spread elements has not been implemented.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralTargetTypeNotConstructible">
+        <source>Cannot initialize type '{0}' with a collection literal because the type is not constructible.</source>
+        <target state="new">Cannot initialize type '{0}' with a collection literal because the type is not constructible.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ConWithUnmanagedCon">
         <source>Type parameter '{1}' has the 'unmanaged' constraint so '{1}' cannot be used as a constraint for '{0}'</source>
         <target state="translated">O parâmetro de tipo '{1}' tem a restrição 'unmanaged' e, por isso, '{1}' não pode ser usado como uma restrição de '{0}'</target>
@@ -557,6 +567,11 @@
         <target state="translated">Uma árvore de expressão pode não conter um acesso de membro de interface de abstrato estático ou virtual</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsCollectionLiteral">
+        <source>An expression tree may not contain a collection literal.</source>
+        <target state="new">An expression tree may not contain a collection literal.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">Uma árvore de expressão não pode conter uma expressão de índice de front-end ('^').</target>
@@ -1832,6 +1847,11 @@
         <target state="translated">operadores verificados, definidos pelo usuário</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureCollectionLiterals">
+        <source>collection literals</source>
+        <target state="new">collection literals</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">retornos de covariante</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
index 670e88fa2dc15..879430e307914 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf
@@ -382,6 +382,16 @@
         <target state="translated">"{0}" не реализует элемент интерфейса "{1}". "{2}" не может реализовывать "{1}".</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralElementNotImplemented">
+        <source>Support for collection literal dictionary and spread elements has not been implemented.</source>
+        <target state="new">Support for collection literal dictionary and spread elements has not been implemented.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralTargetTypeNotConstructible">
+        <source>Cannot initialize type '{0}' with a collection literal because the type is not constructible.</source>
+        <target state="new">Cannot initialize type '{0}' with a collection literal because the type is not constructible.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ConWithUnmanagedCon">
         <source>Type parameter '{1}' has the 'unmanaged' constraint so '{1}' cannot be used as a constraint for '{0}'</source>
         <target state="translated">Параметр типа "{1}" имеет ограничение "unmanaged", поэтому "{1}" не может использоваться в качестве ограничения для "{0}".</target>
@@ -557,6 +567,11 @@
         <target state="translated">Дерево выражения не может содержать доступ к статическому виртуальному или абстрактному элементу интерфейса.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsCollectionLiteral">
+        <source>An expression tree may not contain a collection literal.</source>
+        <target state="new">An expression tree may not contain a collection literal.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">Дерево выражений не может содержать выражение индекса, отсчитываемого с конца ("^").</target>
@@ -1832,6 +1847,11 @@
         <target state="translated">проверенные операторы, определяемые пользователем</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureCollectionLiterals">
+        <source>collection literals</source>
+        <target state="new">collection literals</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">ковариантные возвращаемые значения</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
index 0dc7d4212f72a..31746a11ca113 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf
@@ -382,6 +382,16 @@
         <target state="translated">'{0}, '{1}' arabirim üyesini uygulamıyor. '{2}', '{1}' üyesini uygulayamaz.</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralElementNotImplemented">
+        <source>Support for collection literal dictionary and spread elements has not been implemented.</source>
+        <target state="new">Support for collection literal dictionary and spread elements has not been implemented.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralTargetTypeNotConstructible">
+        <source>Cannot initialize type '{0}' with a collection literal because the type is not constructible.</source>
+        <target state="new">Cannot initialize type '{0}' with a collection literal because the type is not constructible.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ConWithUnmanagedCon">
         <source>Type parameter '{1}' has the 'unmanaged' constraint so '{1}' cannot be used as a constraint for '{0}'</source>
         <target state="translated">'{1}' tür parametresinde 'unmanaged' kısıtlaması olduğundan '{1}', '{0}' için kısıtlama olarak kullanılamaz</target>
@@ -557,6 +567,11 @@
         <target state="translated">İfade ağacı statik sanal veya soyut arabirim üyesi erişimi içermeyebilir</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsCollectionLiteral">
+        <source>An expression tree may not contain a collection literal.</source>
+        <target state="new">An expression tree may not contain a collection literal.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">İfade ağacı, sondan dizin ('^') ifadesi içeremez.</target>
@@ -1832,6 +1847,11 @@
         <target state="translated">kullanıcı tanımlı işleçler işaretlendi</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureCollectionLiterals">
+        <source>collection literals</source>
+        <target state="new">collection literals</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">birlikte değişken dönüşler</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
index c21aed7ba1fdc..6709039f3263d 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf
@@ -382,6 +382,16 @@
         <target state="translated">“{0}”不实现接口成员“{1}”。“{2}”无法实现“{1}”。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralElementNotImplemented">
+        <source>Support for collection literal dictionary and spread elements has not been implemented.</source>
+        <target state="new">Support for collection literal dictionary and spread elements has not been implemented.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralTargetTypeNotConstructible">
+        <source>Cannot initialize type '{0}' with a collection literal because the type is not constructible.</source>
+        <target state="new">Cannot initialize type '{0}' with a collection literal because the type is not constructible.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ConWithUnmanagedCon">
         <source>Type parameter '{1}' has the 'unmanaged' constraint so '{1}' cannot be used as a constraint for '{0}'</source>
         <target state="translated">类型参数“{1}”具有 "unmanaged" 约束，因此“{1}”不能用作“{0}”的约束</target>
@@ -557,6 +567,11 @@
         <target state="translated">表达式树可能不包含静态虚拟或抽象接口成员的访问权限</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsCollectionLiteral">
+        <source>An expression tree may not contain a collection literal.</source>
+        <target state="new">An expression tree may not contain a collection literal.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">表达式树不能包含 from-end 索引("^")表达式。</target>
@@ -1832,6 +1847,11 @@
         <target state="translated">选中的用户定义运算符</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureCollectionLiterals">
+        <source>collection literals</source>
+        <target state="new">collection literals</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">协变返回</target>
diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
index 0251784d7ac06..96706726d6601 100644
--- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
+++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf
@@ -382,6 +382,16 @@
         <target state="translated">'{0}' 未實作介面成員 '{1}'。'{2}' 無法實作 '{1}'。</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralElementNotImplemented">
+        <source>Support for collection literal dictionary and spread elements has not been implemented.</source>
+        <target state="new">Support for collection literal dictionary and spread elements has not been implemented.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="ERR_CollectionLiteralTargetTypeNotConstructible">
+        <source>Cannot initialize type '{0}' with a collection literal because the type is not constructible.</source>
+        <target state="new">Cannot initialize type '{0}' with a collection literal because the type is not constructible.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ConWithUnmanagedCon">
         <source>Type parameter '{1}' has the 'unmanaged' constraint so '{1}' cannot be used as a constraint for '{0}'</source>
         <target state="translated">類型參數 '{1}' 有 'unmanaged' 條件約束，因此 '{1}' 不可作為 '{0}' 的條件約束</target>
@@ -557,6 +567,11 @@
         <target state="translated">運算式樹狀架構不可包含靜態虛擬或抽象介面成員的存取權</target>
         <note />
       </trans-unit>
+      <trans-unit id="ERR_ExpressionTreeContainsCollectionLiteral">
+        <source>An expression tree may not contain a collection literal.</source>
+        <target state="new">An expression tree may not contain a collection literal.</target>
+        <note />
+      </trans-unit>
       <trans-unit id="ERR_ExpressionTreeContainsFromEndIndexExpression">
         <source>An expression tree may not contain a from-end index ('^') expression.</source>
         <target state="translated">運算式樹狀架構不可包含 from-end index ('^') 運算式。</target>
@@ -1832,6 +1847,11 @@
         <target state="translated">已檢查使用者定義的運算子</target>
         <note />
       </trans-unit>
+      <trans-unit id="IDS_FeatureCollectionLiterals">
+        <source>collection literals</source>
+        <target state="new">collection literals</target>
+        <note />
+      </trans-unit>
       <trans-unit id="IDS_FeatureCovariantReturnsForOverrides">
         <source>covariant returns</source>
         <target state="translated">Covariant 傳回</target>
diff --git a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IArrayElementReferenceExpression.cs b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IArrayElementReferenceExpression.cs
index 9f90652fba5c7..69f8647de670f 100644
--- a/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IArrayElementReferenceExpression.cs
+++ b/src/Compilers/CSharp/Test/IOperation/IOperation/IOperationTests_IArrayElementReferenceExpression.cs
@@ -519,9 +519,16 @@ public void F()
 ";
 
             string expectedOperationTree = @"
-IInvalidOperation (OperationKind.Invalid, Type: ?) (Syntax: '[0]')
-  Children(0)";
-            var expectedDiagnostics = new DiagnosticDescription[] { };
+IInvalidOperation (OperationKind.Invalid, Type: null, IsInvalid) (Syntax: '[0]')
+  Children(1):
+      ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 0, IsInvalid) (Syntax: '0')
+";
+            var expectedDiagnostics = new DiagnosticDescription[]
+            {
+                // (6,13): error CS0815: Cannot assign collection literals to an implicitly-typed variable
+                //         var a = /*<bind>*/[0]/*</bind>*/;
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedVariableAssignedBadValue, "a = /*<bind>*/[0]").WithArguments("collection literals").WithLocation(6, 13)
+            };
 
             VerifyOperationTreeAndDiagnosticsForTest<CollectionCreationExpressionSyntax>(source, expectedOperationTree, expectedDiagnostics);
         }
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/CollectionLiteralTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/CollectionLiteralTests.cs
new file mode 100644
index 0000000000000..beb63a89e101f
--- /dev/null
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/CollectionLiteralTests.cs
@@ -0,0 +1,3175 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+#nullable disable
+
+using System.Linq;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Roslyn.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.CSharp.UnitTests
+{
+    public class CollectionLiteralTests : CSharpTestBase
+    {
+        private static string GetCollectionExtensions(bool includeSpan = false)
+        {
+            string source = """
+                using System;
+                using System.Collections;
+                using System.Collections.Generic;
+                using System.Text;
+                static partial class CollectionExtensions
+                {
+                    private static StringBuilder Begin()
+                    {
+                        var builder = new StringBuilder();
+                        builder.Append("[");
+                        return builder;
+                    }
+                    private static string End(StringBuilder builder)
+                    {
+                        builder.Append("]");
+                        return builder.ToString();
+                    }
+                    private static void Append(StringBuilder builder, object value)
+                    {
+                        if (builder.Length > 1) builder.Append(", ");
+                        builder.Append(value is null ? "null" : value.ToString());
+                    }
+                    internal static void Report<T>(this IEnumerable<T> e)
+                    {
+                        var b = Begin();
+                        foreach (var i in e) Append(b, i);
+                        Console.Write(End(b));
+                        Console.Write(", ");
+                    }
+                    internal static void Report(this object o)
+                    {
+                        var b = Begin();
+                        foreach (var i in ((IEnumerable)o)) Append(b, i);
+                        Console.Write(End(b));
+                        Console.Write(", ");
+                    }
+                }
+                """;
+            if (includeSpan)
+            {
+                source += """
+                    static partial class CollectionExtensions
+                    {
+                        internal static void Report<T>(this in Span<T> s)
+                        {
+                            Report((ReadOnlySpan<T>)s);
+                        }
+                        internal static void Report<T>(this in ReadOnlySpan<T> s)
+                        {
+                            var b = Begin();
+                            foreach (var i in s) Append(b, i);
+                            Console.Write(End(b));
+                            Console.Write(", ");
+                        }
+                    }
+                    """;
+            }
+            return source;
+        }
+
+        [Theory]
+        [InlineData(LanguageVersion.CSharp11)]
+        [InlineData(LanguageVersion.Preview)]
+        public void LanguageVersionDiagnostics(LanguageVersion languageVersion)
+        {
+            string source = """
+                using System.Collections.Generic;
+                class Program
+                {
+                    static void Main()
+                    {
+                        object[] x = [];
+                        List<object> y = [1, 2, 3];
+                        List<object[]> z = [[]];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source, parseOptions: TestOptions.Regular.WithLanguageVersion(languageVersion));
+            if (languageVersion == LanguageVersion.CSharp11)
+            {
+                comp.VerifyEmitDiagnostics(
+                    // (6,22): error CS8652: The feature 'collection literals' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    //         object[] x = [];
+                    Diagnostic(ErrorCode.ERR_FeatureInPreview, "[").WithArguments("collection literals").WithLocation(6, 22),
+                    // (7,26): error CS8652: The feature 'collection literals' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    //         List<object> y = [1, 2, 3];
+                    Diagnostic(ErrorCode.ERR_FeatureInPreview, "[").WithArguments("collection literals").WithLocation(7, 26),
+                    // (8,28): error CS8652: The feature 'collection literals' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    //         List<object[]> z = [[]];
+                    Diagnostic(ErrorCode.ERR_FeatureInPreview, "[").WithArguments("collection literals").WithLocation(8, 28),
+                    // (8,29): error CS8652: The feature 'collection literals' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version.
+                    //         List<object[]> z = [[]];
+                    Diagnostic(ErrorCode.ERR_FeatureInPreview, "[").WithArguments("collection literals").WithLocation(8, 29));
+            }
+            else
+            {
+                comp.VerifyEmitDiagnostics();
+            }
+        }
+
+        [Fact]
+        public void NaturalType_01()
+        {
+            string source = """
+                class Program
+                {
+                    static void Main()
+                    {
+                        object x = [];
+                        dynamic y = [];
+                        var z = [];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (5,20): error CS9500: Cannot initialize type 'object' with a collection literal because the type is not constructible.
+                //         object x = [];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("object").WithLocation(5, 20),
+                // (6,21): error CS9500: Cannot initialize type 'dynamic' with a collection literal because the type is not constructible.
+                //         dynamic y = [];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("dynamic").WithLocation(6, 21),
+                // (7,13): error CS0815: Cannot assign collection literals to an implicitly-typed variable
+                //         var z = [];
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedVariableAssignedBadValue, "z = []").WithArguments("collection literals").WithLocation(7, 13));
+        }
+
+        [Fact]
+        public void NaturalType_02()
+        {
+            string source = """
+                class Program
+                {
+                    static void Main()
+                    {
+                        object x = [1];
+                        dynamic y = [2];
+                        var z = [3];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (5,20): error CS9500: Cannot initialize type 'object' with a collection literal because the type is not constructible.
+                //         object x = [1];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[1]").WithArguments("object").WithLocation(5, 20),
+                // (6,21): error CS9500: Cannot initialize type 'dynamic' with a collection literal because the type is not constructible.
+                //         dynamic y = [2];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[2]").WithArguments("dynamic").WithLocation(6, 21),
+                // (7,13): error CS0815: Cannot assign collection literals to an implicitly-typed variable
+                //         var z = [3];
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedVariableAssignedBadValue, "z = [3]").WithArguments("collection literals").WithLocation(7, 13));
+        }
+
+        [Fact]
+        public void NaturalType_03()
+        {
+            string source = """
+                class Program
+                {
+                    static void Main()
+                    {
+                        object[] x = [[]];
+                        object[] y = [[2]];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (5,23): error CS9500: Cannot initialize type 'object' with a collection literal because the type is not constructible.
+                //         object[] x = [[]];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("object").WithLocation(5, 23),
+                // (6,23): error CS9500: Cannot initialize type 'object' with a collection literal because the type is not constructible.
+                //         object[] y = [[2]];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[2]").WithArguments("object").WithLocation(6, 23));
+        }
+
+        [Fact]
+        public void NaturalType_04()
+        {
+            string source = """
+                class Program
+                {
+                    static void Main()
+                    {
+                        F([]);
+                        F([[]]);
+                    }
+                    static T F<T>(T t) => t;
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (5,9): error CS0411: The type arguments for method 'Program.F<T>(T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         F([]);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F").WithArguments("Program.F<T>(T)").WithLocation(5, 9),
+                // (6,9): error CS0411: The type arguments for method 'Program.F<T>(T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         F([[]]);
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F").WithArguments("Program.F<T>(T)").WithLocation(6, 9));
+        }
+
+        [Fact]
+        public void NaturalType_05()
+        {
+            string source = """
+                class Program
+                {
+                    static void Main()
+                    {
+                        F([1, 2]).Report();
+                        F([[3, 4]]).Report();
+                    }
+                    static T F<T>(T t) => t;
+                }
+                """;
+            // PROTOTYPE: Verify expectedOutput: "..." when natural type is supported.
+            var comp = CreateCompilation(new[] { source, GetCollectionExtensions() });
+            comp.VerifyEmitDiagnostics(
+                // (5,9): error CS0411: The type arguments for method 'Program.F<T>(T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         F([1, 2]).Report();
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F").WithArguments("Program.F<T>(T)").WithLocation(5, 9),
+                // (6,9): error CS0411: The type arguments for method 'Program.F<T>(T)' cannot be inferred from the usage. Try specifying the type arguments explicitly.
+                //         F([[3, 4]]).Report();
+                Diagnostic(ErrorCode.ERR_CantInferMethTypeArgs, "F").WithArguments("Program.F<T>(T)").WithLocation(6, 9));
+        }
+
+        [Fact]
+        public void NaturalType_06()
+        {
+            string source = """
+                using System;
+                class Program
+                {
+                    static void Main()
+                    {
+                        var d1 = () => [];
+                        Func<int[]> d2 = () => [];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (6,18): error CS8917: The delegate type could not be inferred.
+                //         var d1 = () => [];
+                Diagnostic(ErrorCode.ERR_CannotInferDelegateType, "() => []").WithLocation(6, 18));
+        }
+
+        [Fact]
+        public void NaturalType_07()
+        {
+            string source = """
+                using System.Collections;
+                using System.Collections.Generic;
+                class Program
+                {
+                    static void Main()
+                    {
+                        IEnumerable x = [];
+                        IEnumerable<int> y = [];
+                        IList<object> z = [];
+                        IDictionary<string, int> w = [];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (7,25): error CS0144: Cannot create an instance of the abstract type or interface 'IEnumerable'
+                //         IEnumerable x = [];
+                Diagnostic(ErrorCode.ERR_NoNewAbstract, "[]").WithArguments("System.Collections.IEnumerable").WithLocation(7, 25),
+                // (7,25): error CS9500: Cannot initialize type 'IEnumerable' with a collection literal because the type is not constructible.
+                //         IEnumerable x = [];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("System.Collections.IEnumerable").WithLocation(7, 25),
+                // (8,30): error CS0144: Cannot create an instance of the abstract type or interface 'IEnumerable<int>'
+                //         IEnumerable<int> y = [];
+                Diagnostic(ErrorCode.ERR_NoNewAbstract, "[]").WithArguments("System.Collections.Generic.IEnumerable<int>").WithLocation(8, 30),
+                // (9,27): error CS0144: Cannot create an instance of the abstract type or interface 'IList<object>'
+                //         IList<object> z = [];
+                Diagnostic(ErrorCode.ERR_NoNewAbstract, "[]").WithArguments("System.Collections.Generic.IList<object>").WithLocation(9, 27),
+                // (10,38): error CS0144: Cannot create an instance of the abstract type or interface 'IDictionary<string, int>'
+                //         IDictionary<string, int> w = [];
+                Diagnostic(ErrorCode.ERR_NoNewAbstract, "[]").WithArguments("System.Collections.Generic.IDictionary<string, int>").WithLocation(10, 38));
+        }
+
+        [Fact]
+        public void Array_01()
+        {
+            string source = """
+                class Program
+                {
+                    static int[] Create1() => [];
+                    static object[] Create2() => [1, 2];
+                    static int[] Create3() => [3, 4, 5];
+                    static long?[] Create4() => [null, 7];
+                    static void Main()
+                    {
+                        Create1().Report();
+                        Create2().Report();
+                        Create3().Report();
+                        Create4().Report();
+                    }
+                }
+                """;
+            var verifier = CompileAndVerify(new[] { source, GetCollectionExtensions() }, expectedOutput: "[], [1, 2], [3, 4, 5], [null, 7], ");
+            verifier.VerifyIL("Program.Create1", """
+                {
+                  // Code size        7 (0x7)
+                  .maxstack  1
+                  IL_0000:  ldc.i4.0
+                  IL_0001:  newarr     "int"
+                  IL_0006:  ret
+                }
+                """);
+            verifier.VerifyIL("Program.Create2", """
+                {
+                  // Code size       25 (0x19)
+                  .maxstack  4
+                  IL_0000:  ldc.i4.2
+                  IL_0001:  newarr     "object"
+                  IL_0006:  dup
+                  IL_0007:  ldc.i4.0
+                  IL_0008:  ldc.i4.1
+                  IL_0009:  box        "int"
+                  IL_000e:  stelem.ref
+                  IL_000f:  dup
+                  IL_0010:  ldc.i4.1
+                  IL_0011:  ldc.i4.2
+                  IL_0012:  box        "int"
+                  IL_0017:  stelem.ref
+                  IL_0018:  ret
+                }
+                """);
+            verifier.VerifyIL("Program.Create3", """
+                {
+                  // Code size       18 (0x12)
+                  .maxstack  3
+                  IL_0000:  ldc.i4.3
+                  IL_0001:  newarr     "int"
+                  IL_0006:  dup
+                  IL_0007:  ldtoken    "<PrivateImplementationDetails>.__StaticArrayInitTypeSize=12 <PrivateImplementationDetails>.CE99AE045C8B2A2A8A58FD1A2120956E74E90322EEF45F7DFE1CA73EEFE655D4"
+                  IL_000c:  call       "void System.Runtime.CompilerServices.RuntimeHelpers.InitializeArray(System.Array, System.RuntimeFieldHandle)"
+                  IL_0011:  ret
+                }
+                """);
+            verifier.VerifyIL("Program.Create4", """
+                {
+                  // Code size       21 (0x15)
+                  .maxstack  4
+                  IL_0000:  ldc.i4.2
+                  IL_0001:  newarr     "long?"
+                  IL_0006:  dup
+                  IL_0007:  ldc.i4.1
+                  IL_0008:  ldc.i4.7
+                  IL_0009:  conv.i8
+                  IL_000a:  newobj     "long?..ctor(long)"
+                  IL_000f:  stelem     "long?"
+                  IL_0014:  ret
+                }
+                """);
+        }
+
+        [Fact]
+        public void Array_02()
+        {
+            string source = """
+                using System;
+                class Program
+                {
+                    static int[][] Create1() => [];
+                    static object[][] Create2() => [[]];
+                    static object[][] Create3() => [[1], [2, 3]];
+                    static void Main()
+                    {
+                        Report(Create1());
+                        Report(Create2());
+                        Report(Create3());
+                    }
+                    static void Report<T>(T[][] a)
+                    {
+                        Console.Write("Length={0}, ", a.Length);
+                        foreach (var x in a)
+                        {
+                            Console.Write("Length={0}, ", x.Length);
+                            foreach (var y in x)
+                                Console.Write("{0}, ", y);
+                        }
+                        Console.WriteLine();
+                    }
+                }
+                """;
+            var verifier = CompileAndVerify(source, expectedOutput: """
+                Length=0, 
+                Length=1, Length=0, 
+                Length=2, Length=1, 1, Length=2, 2, 3, 
+                """);
+            verifier.VerifyIL("Program.Create1", """
+                {
+                  // Code size        7 (0x7)
+                  .maxstack  1
+                  IL_0000:  ldc.i4.0
+                  IL_0001:  newarr     "int[]"
+                  IL_0006:  ret
+                }
+                """);
+            verifier.VerifyIL("Program.Create2", """
+                {
+                  // Code size       16 (0x10)
+                  .maxstack  4
+                  IL_0000:  ldc.i4.1
+                  IL_0001:  newarr     "object[]"
+                  IL_0006:  dup
+                  IL_0007:  ldc.i4.0
+                  IL_0008:  ldc.i4.0
+                  IL_0009:  newarr     "object"
+                  IL_000e:  stelem.ref
+                  IL_000f:  ret
+                }
+                """);
+            verifier.VerifyIL("Program.Create3", """
+                {
+                  // Code size       52 (0x34)
+                  .maxstack  7
+                  IL_0000:  ldc.i4.2
+                  IL_0001:  newarr     "object[]"
+                  IL_0006:  dup
+                  IL_0007:  ldc.i4.0
+                  IL_0008:  ldc.i4.1
+                  IL_0009:  newarr     "object"
+                  IL_000e:  dup
+                  IL_000f:  ldc.i4.0
+                  IL_0010:  ldc.i4.1
+                  IL_0011:  box        "int"
+                  IL_0016:  stelem.ref
+                  IL_0017:  stelem.ref
+                  IL_0018:  dup
+                  IL_0019:  ldc.i4.1
+                  IL_001a:  ldc.i4.2
+                  IL_001b:  newarr     "object"
+                  IL_0020:  dup
+                  IL_0021:  ldc.i4.0
+                  IL_0022:  ldc.i4.2
+                  IL_0023:  box        "int"
+                  IL_0028:  stelem.ref
+                  IL_0029:  dup
+                  IL_002a:  ldc.i4.1
+                  IL_002b:  ldc.i4.3
+                  IL_002c:  box        "int"
+                  IL_0031:  stelem.ref
+                  IL_0032:  stelem.ref
+                  IL_0033:  ret
+                }
+                """);
+        }
+
+        [Fact]
+        public void Array_03()
+        {
+            string source = """
+                class Program
+                {
+                    static void Main()
+                    {
+                        object o;
+                        o = (int[])[];
+                        o.Report();
+                        o = (long?[])[null, 2];
+                        o.Report();
+                    }
+                }
+                """;
+            CompileAndVerify(new[] { source, GetCollectionExtensions() }, expectedOutput: "[], [null, 2], ");
+        }
+
+        [Fact]
+        public void Array_04()
+        {
+            string source = """
+                class Program
+                {
+                    static void Main()
+                    {
+                        object[,] x = [];
+                        int[,] y = [null, 2];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (5,23): error CS9500: Cannot initialize type 'object[*,*]' with a collection literal because the type is not constructible.
+                //         object[,] x = [];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("object[*,*]").WithLocation(5, 23),
+                // (6,20): error CS9500: Cannot initialize type 'int[*,*]' with a collection literal because the type is not constructible.
+                //         int[,] y = [null, 2];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[null, 2]").WithArguments("int[*,*]").WithLocation(6, 20),
+                // (6,21): error CS0037: Cannot convert null to 'int' because it is a non-nullable value type
+                //         int[,] y = [null, 2];
+                Diagnostic(ErrorCode.ERR_ValueCantBeNull, "null").WithArguments("int").WithLocation(6, 21));
+        }
+
+        [Fact]
+        public void Array_05()
+        {
+            string source = """
+                class Program
+                {
+                    static void Main()
+                    {
+                        int[,] z = [[1, 2], [3, 4]];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (5,20): error CS9500: Cannot initialize type 'int[*,*]' with a collection literal because the type is not constructible.
+                //         int[,] z = [[1, 2], [3, 4]];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[[1, 2], [3, 4]]").WithArguments("int[*,*]").WithLocation(5, 20),
+                // (5,21): error CS9500: Cannot initialize type 'int' with a collection literal because the type is not constructible.
+                //         int[,] z = [[1, 2], [3, 4]];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[1, 2]").WithArguments("int").WithLocation(5, 21),
+                // (5,29): error CS9500: Cannot initialize type 'int' with a collection literal because the type is not constructible.
+                //         int[,] z = [[1, 2], [3, 4]];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[3, 4]").WithArguments("int").WithLocation(5, 29));
+        }
+
+        [ConditionalTheory(typeof(CoreClrOnly))]
+        [CombinatorialData]
+        public void Span_01(bool useReadOnlySpan)
+        {
+            string spanType = useReadOnlySpan ? "ReadOnlySpan" : "Span";
+            string source = $$"""
+                using System;
+                class Program
+                {
+                    static {{spanType}}<int> Create1() => [];
+                    static {{spanType}}<object> Create2() => [1, 2];
+                    static {{spanType}}<int> Create3() => [3, 4, 5];
+                    static {{spanType}}<long?> Create4() => [null, 7];
+                    static void Main()
+                    {
+                        Create1().Report();
+                        Create2().Report();
+                        Create3().Report();
+                        Create4().Report();
+                    }
+                }
+                """;
+            var verifier = CompileAndVerify(new[] { source, GetCollectionExtensions(includeSpan: true) }, targetFramework: TargetFramework.Net70, verify: Verification.Skipped, expectedOutput: "[], [1, 2], [3, 4, 5], [null, 7], ");
+            verifier.VerifyIL("Program.Create1", $$"""
+                {
+                  // Code size       12 (0xc)
+                  .maxstack  1
+                  IL_0000:  ldc.i4.0
+                  IL_0001:  newarr     "int"
+                  IL_0006:  newobj     "System.{{spanType}}<int>..ctor(int[])"
+                  IL_000b:  ret
+                }
+                """);
+            verifier.VerifyIL("Program.Create2", $$"""
+                {
+                  // Code size       30 (0x1e)
+                  .maxstack  4
+                  IL_0000:  ldc.i4.2
+                  IL_0001:  newarr     "object"
+                  IL_0006:  dup
+                  IL_0007:  ldc.i4.0
+                  IL_0008:  ldc.i4.1
+                  IL_0009:  box        "int"
+                  IL_000e:  stelem.ref
+                  IL_000f:  dup
+                  IL_0010:  ldc.i4.1
+                  IL_0011:  ldc.i4.2
+                  IL_0012:  box        "int"
+                  IL_0017:  stelem.ref
+                  IL_0018:  newobj     "System.{{spanType}}<object>..ctor(object[])"
+                  IL_001d:  ret
+                }
+                """);
+            if (useReadOnlySpan)
+            {
+                verifier.VerifyIL("Program.Create3", """
+                    {
+                      // Code size       11 (0xb)
+                      .maxstack  1
+                      IL_0000:  ldtoken    "<PrivateImplementationDetails>.__StaticArrayInitTypeSize=12_Align=4 <PrivateImplementationDetails>.CE99AE045C8B2A2A8A58FD1A2120956E74E90322EEF45F7DFE1CA73EEFE655D44"
+                      IL_0005:  call       "System.ReadOnlySpan<int> System.Runtime.CompilerServices.RuntimeHelpers.CreateSpan<int>(System.RuntimeFieldHandle)"
+                      IL_000a:  ret
+                    }
+                    """);
+            }
+            else
+            {
+                verifier.VerifyIL("Program.Create3", """
+                    {
+                      // Code size       23 (0x17)
+                      .maxstack  3
+                      IL_0000:  ldc.i4.3
+                      IL_0001:  newarr     "int"
+                      IL_0006:  dup
+                      IL_0007:  ldtoken    "<PrivateImplementationDetails>.__StaticArrayInitTypeSize=12 <PrivateImplementationDetails>.CE99AE045C8B2A2A8A58FD1A2120956E74E90322EEF45F7DFE1CA73EEFE655D4"
+                      IL_000c:  call       "void System.Runtime.CompilerServices.RuntimeHelpers.InitializeArray(System.Array, System.RuntimeFieldHandle)"
+                      IL_0011:  newobj     "System.Span<int>..ctor(int[])"
+                      IL_0016:  ret
+                    }
+                    """);
+            }
+            verifier.VerifyIL("Program.Create4", $$"""
+                {
+                  // Code size       26 (0x1a)
+                  .maxstack  4
+                  IL_0000:  ldc.i4.2
+                  IL_0001:  newarr     "long?"
+                  IL_0006:  dup
+                  IL_0007:  ldc.i4.1
+                  IL_0008:  ldc.i4.7
+                  IL_0009:  conv.i8
+                  IL_000a:  newobj     "long?..ctor(long)"
+                  IL_000f:  stelem     "long?"
+                  IL_0014:  newobj     "System.{{spanType}}<long?>..ctor(long?[])"
+                  IL_0019:  ret
+                }
+                """);
+        }
+
+        [ConditionalTheory(typeof(CoreClrOnly))]
+        [CombinatorialData]
+        public void Span_02(bool useReadOnlySpan)
+        {
+            string spanType = useReadOnlySpan ? "ReadOnlySpan" : "Span";
+            string source = $$"""
+                using System;
+                class Program
+                {
+                    static void Main()
+                    {
+                        {{spanType}}<string> x = [];
+                        {{spanType}}<int> y = [1, 2, 3];
+                        x.Report();
+                        y.Report();
+                    }
+                }
+                """;
+            CompileAndVerify(new[] { source, GetCollectionExtensions(includeSpan: true) }, targetFramework: TargetFramework.Net70, verify: Verification.Skipped, expectedOutput: "[], [1, 2, 3], ");
+        }
+
+        [ConditionalTheory(typeof(CoreClrOnly))]
+        [CombinatorialData]
+        public void Span_03(bool useReadOnlySpan)
+        {
+            string spanType = useReadOnlySpan ? "ReadOnlySpan" : "Span";
+            string source = $$"""
+                using System;
+                class Program
+                {
+                    static void Main()
+                    {
+                        var x = ({{spanType}}<string>)[];
+                        var y = ({{spanType}}<int>)[1, 2, 3];
+                        x.Report();
+                        y.Report();
+                    }
+                }
+                """;
+            CompileAndVerify(new[] { source, GetCollectionExtensions(includeSpan: true) }, targetFramework: TargetFramework.Net70, verify: Verification.Skipped, expectedOutput: "[], [1, 2, 3], ");
+        }
+
+        [ConditionalTheory(typeof(CoreClrOnly))]
+        [CombinatorialData]
+        public void Span_04(bool useReadOnlySpan)
+        {
+            string spanType = useReadOnlySpan ? "ReadOnlySpan" : "Span";
+            string source = $$"""
+                using System;
+                class Program
+                {
+                    static ref readonly {{spanType}}<int> F1()
+                    {
+                        return ref F2<int>([]);
+                    }
+                    static ref readonly {{spanType}}<T> F2<T>(in {{spanType}}<T> s)
+                    {
+                        return ref s;
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source, targetFramework: TargetFramework.Net70);
+            comp.VerifyDiagnostics(
+                // (6,20): error CS8347: Cannot use a result of 'Program.F2<int>(in Span<int>)' in this context because it may expose variables referenced by parameter 's' outside of their declaration scope
+                //         return ref F2<int>([]);
+                Diagnostic(ErrorCode.ERR_EscapeCall, "F2<int>([])").WithArguments($"Program.F2<int>(in System.{spanType}<int>)", "s").WithLocation(6, 20),
+                // (6,28): error CS8156: An expression cannot be used in this context because it may not be passed or returned by reference
+                //         return ref F2<int>([]);
+                Diagnostic(ErrorCode.ERR_RefReturnLvalueExpected, "[]").WithLocation(6, 28));
+        }
+
+        [ConditionalTheory(typeof(CoreClrOnly))]
+        [CombinatorialData]
+        public void Span_05(bool useReadOnlySpan)
+        {
+            string spanType = useReadOnlySpan ? "ReadOnlySpan" : "Span";
+            string source = $$"""
+                using System;
+                class Program
+                {
+                    static ref readonly {{spanType}}<int> F1()
+                    {
+                        return ref F2<int>([]);
+                    }
+                    static ref readonly {{spanType}}<T> F2<T>(scoped in {{spanType}}<T> s)
+                    {
+                        throw null;
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source, targetFramework: TargetFramework.Net70);
+            comp.VerifyDiagnostics();
+        }
+
+        [ConditionalFact(typeof(CoreClrOnly))]
+        public void Span_MissingConstructor()
+        {
+            string source = """
+                using System;
+                class Program
+                {
+                    static void Main()
+                    {
+                        Span<string> x = [];
+                        ReadOnlySpan<int> y = [1, 2, 3];
+                    }
+                }
+                """;
+
+            var comp = CreateCompilation(source, targetFramework: TargetFramework.Net70);
+            comp.MakeMemberMissing(WellKnownMember.System_Span_T__ctor_Array);
+            comp.VerifyEmitDiagnostics(
+                // (6,26): error CS0656: Missing compiler required member 'System.Span`1..ctor'
+                //         Span<string> x = [];
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "[]").WithArguments("System.Span`1", ".ctor").WithLocation(6, 26));
+
+            comp = CreateCompilation(source, targetFramework: TargetFramework.Net70);
+            comp.MakeMemberMissing(WellKnownMember.System_ReadOnlySpan_T__ctor_Array);
+            comp.VerifyEmitDiagnostics(
+                // (7,31): error CS0656: Missing compiler required member 'System.ReadOnlySpan`1..ctor'
+                //         ReadOnlySpan<int> y = [1, 2, 3];
+                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "[1, 2, 3]").WithArguments("System.ReadOnlySpan`1", ".ctor").WithLocation(7, 31));
+        }
+
+        [Fact]
+        public void InterfaceType()
+        {
+            string source = """
+                using System;
+                using System.Collections;
+                using System.Runtime.InteropServices;
+
+                [ComImport]
+                [Guid("1FC6664D-C61E-4131-81CD-A3EE0DD6098F")]
+                [CoClass(typeof(C))]
+                interface I : IEnumerable
+                {
+                    void Add(int i);
+                }
+
+                class C : I
+                {
+                    IEnumerator IEnumerable.GetEnumerator() => null;
+                    void I.Add(int i) { }
+                }
+
+                class Program
+                {
+                    static void Main()
+                    {
+                        I i;
+                        i = new() { };
+                        i = new() { 1, 2 };
+                        i = [];
+                        i = [3, 4];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (26,13): error CS0144: Cannot create an instance of the abstract type or interface 'I'
+                //         i = [];
+                Diagnostic(ErrorCode.ERR_NoNewAbstract, "[]").WithArguments("I").WithLocation(26, 13),
+                // (27,13): error CS0144: Cannot create an instance of the abstract type or interface 'I'
+                //         i = [3, 4];
+                Diagnostic(ErrorCode.ERR_NoNewAbstract, "[3, 4]").WithArguments("I").WithLocation(27, 13));
+        }
+
+        [Fact]
+        public void EnumType_01()
+        {
+            string source = """
+                enum E { }
+                class Program
+                {
+                    static void Main()
+                    {
+                        E e;
+                        e = [];
+                        e = [1, 2];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (7,13): error CS9500: Cannot initialize type 'E' with a collection literal because the type is not constructible.
+                //         e = [];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("E").WithLocation(7, 13),
+                // (8,13): error CS9500: Cannot initialize type 'E' with a collection literal because the type is not constructible.
+                //         e = [1, 2];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[1, 2]").WithArguments("E").WithLocation(8, 13));
+        }
+
+        [Fact]
+        public void EnumType_02()
+        {
+            string sourceA = """
+                namespace System
+                {
+                    public class Object { }
+                    public abstract class ValueType { }
+                    public class String { }
+                    public class Type { }
+                    public struct Void { }
+                    public struct Boolean { }
+                    public struct Int32 { }
+                    public struct Enum : System.Collections.IEnumerable { }
+                }
+                namespace System.Collections
+                {
+                    public interface IEnumerable { }
+                }
+                """;
+            string sourceB = """
+                enum E { }
+                class Program
+                {
+                    static void Main()
+                    {
+                        E e;
+                        e = [];
+                        e = [1, 2];
+                    }
+                }
+                """;
+            var comp = CreateEmptyCompilation(new[] { sourceA, sourceB }, parseOptions: TestOptions.RegularPreview.WithNoRefSafetyRulesAttribute());
+            comp.VerifyEmitDiagnostics(
+                // warning CS8021: No value for RuntimeMetadataVersion found. No assembly containing System.Object was found nor was a value for RuntimeMetadataVersion specified through options.
+                Diagnostic(ErrorCode.WRN_NoRuntimeMetadataVersion).WithLocation(1, 1),
+                // (8,14): error CS1061: 'E' does not contain a definition for 'Add' and no accessible extension method 'Add' accepting a first argument of type 'E' could be found (are you missing a using directive or an assembly reference?)
+                //         e = [1, 2];
+                Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "1").WithArguments("E", "Add").WithLocation(8, 14),
+                // (8,17): error CS1061: 'E' does not contain a definition for 'Add' and no accessible extension method 'Add' accepting a first argument of type 'E' could be found (are you missing a using directive or an assembly reference?)
+                //         e = [1, 2];
+                Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "2").WithArguments("E", "Add").WithLocation(8, 17));
+        }
+
+        [Fact]
+        public void DelegateType_01()
+        {
+            string source = """
+                delegate void D();
+                class Program
+                {
+                    static void Main()
+                    {
+                        D d;
+                        d = [];
+                        d = [1, 2];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (7,13): error CS7036: There is no argument given that corresponds to the required parameter 'object' of 'D.D(object, IntPtr)'
+                //         d = [];
+                Diagnostic(ErrorCode.ERR_NoCorrespondingArgument, "[]").WithArguments("object", "D.D(object, System.IntPtr)").WithLocation(7, 13),
+                // (7,13): error CS9500: Cannot initialize type 'D' with a collection literal because the type is not constructible.
+                //         d = [];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("D").WithLocation(7, 13),
+                // (8,13): error CS7036: There is no argument given that corresponds to the required parameter 'object' of 'D.D(object, IntPtr)'
+                //         d = [1, 2];
+                Diagnostic(ErrorCode.ERR_NoCorrespondingArgument, "[1, 2]").WithArguments("object", "D.D(object, System.IntPtr)").WithLocation(8, 13),
+                // (8,13): error CS9500: Cannot initialize type 'D' with a collection literal because the type is not constructible.
+                //         d = [1, 2];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[1, 2]").WithArguments("D").WithLocation(8, 13));
+        }
+
+        [Fact]
+        public void DelegateType_02()
+        {
+            string sourceA = """
+                namespace System
+                {
+                    public class Object { }
+                    public abstract class ValueType { }
+                    public class String { }
+                    public class Type { }
+                    public struct Void { }
+                    public struct Boolean { }
+                    public struct Int32 { }
+                    public struct IntPtr { }
+                    public abstract class Delegate : System.Collections.IEnumerable { }
+                    public abstract class MulticastDelegate : Delegate { }
+                }
+                namespace System.Collections
+                {
+                    public interface IEnumerable { }
+                }
+                """;
+            string sourceB = """
+                delegate void D();
+                class Program
+                {
+                    static void Main()
+                    {
+                        D d;
+                        d = [];
+                        d = [1, 2];
+                    }
+                }
+                """;
+            var comp = CreateEmptyCompilation(new[] { sourceA, sourceB }, parseOptions: TestOptions.RegularPreview.WithNoRefSafetyRulesAttribute());
+            comp.VerifyEmitDiagnostics(
+                // warning CS8021: No value for RuntimeMetadataVersion found. No assembly containing System.Object was found nor was a value for RuntimeMetadataVersion specified through options.
+                Diagnostic(ErrorCode.WRN_NoRuntimeMetadataVersion).WithLocation(1, 1),
+                // (7,13): error CS7036: There is no argument given that corresponds to the required parameter 'object' of 'D.D(object, IntPtr)'
+                //         d = [];
+                Diagnostic(ErrorCode.ERR_NoCorrespondingArgument, "[]").WithArguments("object", "D.D(object, System.IntPtr)").WithLocation(7, 13),
+                // (8,13): error CS7036: There is no argument given that corresponds to the required parameter 'object' of 'D.D(object, IntPtr)'
+                //         d = [1, 2];
+                Diagnostic(ErrorCode.ERR_NoCorrespondingArgument, "[1, 2]").WithArguments("object", "D.D(object, System.IntPtr)").WithLocation(8, 13),
+                // (8,14): error CS1061: 'D' does not contain a definition for 'Add' and no accessible extension method 'Add' accepting a first argument of type 'D' could be found (are you missing a using directive or an assembly reference?)
+                //         d = [1, 2];
+                Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "1").WithArguments("D", "Add").WithLocation(8, 14),
+                // (8,17): error CS1061: 'D' does not contain a definition for 'Add' and no accessible extension method 'Add' accepting a first argument of type 'D' could be found (are you missing a using directive or an assembly reference?)
+                //         d = [1, 2];
+                Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "2").WithArguments("D", "Add").WithLocation(8, 17));
+        }
+
+        [Fact]
+        public void PointerType()
+        {
+            string source = """
+                class Program
+                {
+                    unsafe static void Main()
+                    {
+                        int* x = [];
+                        int* y = [1, 2];
+                        var z = (int*)[3];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source, options: TestOptions.UnsafeReleaseExe);
+            comp.VerifyEmitDiagnostics(
+                // (5,18): error CS9500: Cannot initialize type 'int*' with a collection literal because the type is not constructible.
+                //         int* x = [];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("int*").WithLocation(5, 18),
+                // (6,18): error CS9500: Cannot initialize type 'int*' with a collection literal because the type is not constructible.
+                //         int* y = [1, 2];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[1, 2]").WithArguments("int*").WithLocation(6, 18),
+                // (7,23): error CS9500: Cannot initialize type 'int*' with a collection literal because the type is not constructible.
+                //         var z = (int*)[3];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[3]").WithArguments("int*").WithLocation(7, 23));
+        }
+
+        [Fact]
+        public void FunctionPointerType()
+        {
+            string source = """
+                class Program
+                {
+                    unsafe static void Main()
+                    {
+                        delegate*<void> x = [];
+                        delegate*<void> y = [1, 2];
+                        var z = (delegate*<void>)[3];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source, options: TestOptions.UnsafeReleaseExe);
+            comp.VerifyEmitDiagnostics(
+                // (5,29): error CS9500: Cannot initialize type 'delegate*<void>' with a collection literal because the type is not constructible.
+                //         delegate*<void> x = [];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("delegate*<void>").WithLocation(5, 29),
+                // (6,29): error CS9500: Cannot initialize type 'delegate*<void>' with a collection literal because the type is not constructible.
+                //         delegate*<void> y = [1, 2];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[1, 2]").WithArguments("delegate*<void>").WithLocation(6, 29),
+                // (7,34): error CS9500: Cannot initialize type 'delegate*<void>' with a collection literal because the type is not constructible.
+                //         var z = (delegate*<void>)[3];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[3]").WithArguments("delegate*<void>").WithLocation(7, 34));
+        }
+
+        [Fact]
+        public void CollectionInitializerType_01()
+        {
+            string source = """
+                using System.Collections.Generic;
+                class Program
+                {
+                    static List<int> Create1() => [];
+                    static List<object> Create2() => [1, 2];
+                    static List<int> Create3() => [3, 4, 5];
+                    static List<long?> Create4() => [null, 7];
+                    static void Main()
+                    {
+                        Create1().Report();
+                        Create2().Report();
+                        Create3().Report();
+                        Create4().Report();
+                    }
+                }
+                """;
+            var verifier = CompileAndVerify(new[] { source, GetCollectionExtensions() }, expectedOutput: "[], [1, 2], [3, 4, 5], [null, 7], ");
+            verifier.VerifyIL("Program.Create1", """
+                {
+                  // Code size        6 (0x6)
+                  .maxstack  1
+                  IL_0000:  newobj     "System.Collections.Generic.List<int>..ctor()"
+                  IL_0005:  ret
+                }
+                """);
+            verifier.VerifyIL("Program.Create2", """
+                {
+                  // Code size       30 (0x1e)
+                  .maxstack  3
+                  IL_0000:  newobj     "System.Collections.Generic.List<object>..ctor()"
+                  IL_0005:  dup
+                  IL_0006:  ldc.i4.1
+                  IL_0007:  box        "int"
+                  IL_000c:  callvirt   "void System.Collections.Generic.List<object>.Add(object)"
+                  IL_0011:  dup
+                  IL_0012:  ldc.i4.2
+                  IL_0013:  box        "int"
+                  IL_0018:  callvirt   "void System.Collections.Generic.List<object>.Add(object)"
+                  IL_001d:  ret
+                }
+                """);
+            verifier.VerifyIL("Program.Create3", """
+                {
+                  // Code size       27 (0x1b)
+                  .maxstack  3
+                  IL_0000:  newobj     "System.Collections.Generic.List<int>..ctor()"
+                  IL_0005:  dup
+                  IL_0006:  ldc.i4.3
+                  IL_0007:  callvirt   "void System.Collections.Generic.List<int>.Add(int)"
+                  IL_000c:  dup
+                  IL_000d:  ldc.i4.4
+                  IL_000e:  callvirt   "void System.Collections.Generic.List<int>.Add(int)"
+                  IL_0013:  dup
+                  IL_0014:  ldc.i4.5
+                  IL_0015:  callvirt   "void System.Collections.Generic.List<int>.Add(int)"
+                  IL_001a:  ret
+                }
+                """);
+            verifier.VerifyIL("Program.Create4", """
+                {
+                  // Code size       34 (0x22)
+                  .maxstack  3
+                  .locals init (long? V_0)
+                  IL_0000:  newobj     "System.Collections.Generic.List<long?>..ctor()"
+                  IL_0005:  dup
+                  IL_0006:  ldloca.s   V_0
+                  IL_0008:  initobj    "long?"
+                  IL_000e:  ldloc.0
+                  IL_000f:  callvirt   "void System.Collections.Generic.List<long?>.Add(long?)"
+                  IL_0014:  dup
+                  IL_0015:  ldc.i4.7
+                  IL_0016:  conv.i8
+                  IL_0017:  newobj     "long?..ctor(long)"
+                  IL_001c:  callvirt   "void System.Collections.Generic.List<long?>.Add(long?)"
+                  IL_0021:  ret
+                }
+                """);
+        }
+
+        [Fact]
+        public void CollectionInitializerType_02()
+        {
+            string source = """
+                S s;
+                s = [];
+                s = [1, 2];
+                struct S { }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (2,5): error CS9500: Cannot initialize type 'S' with a collection literal because the type is not constructible.
+                // s = [];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("S").WithLocation(2, 5),
+                // (3,5): error CS9500: Cannot initialize type 'S' with a collection literal because the type is not constructible.
+                // s = [1, 2];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[1, 2]").WithArguments("S").WithLocation(3, 5));
+        }
+
+        [Fact]
+        public void CollectionInitializerType_03()
+        {
+            string source = """
+                using System.Collections;
+                S s;
+                s = [];
+                struct S : IEnumerable
+                {
+                    IEnumerator IEnumerable.GetEnumerator() => throw null;
+                }
+                """;
+            CompileAndVerify(source, expectedOutput: "");
+
+            source = """
+                using System.Collections;
+                S s;
+                s = [1, 2];
+                struct S : IEnumerable
+                {
+                    IEnumerator IEnumerable.GetEnumerator() => throw null;
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (3,6): error CS1061: 'S' does not contain a definition for 'Add' and no accessible extension method 'Add' accepting a first argument of type 'S' could be found (are you missing a using directive or an assembly reference?)
+                // s = [1, 2];
+                Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "1").WithArguments("S", "Add").WithLocation(3, 6),
+                // (3,9): error CS1061: 'S' does not contain a definition for 'Add' and no accessible extension method 'Add' accepting a first argument of type 'S' could be found (are you missing a using directive or an assembly reference?)
+                // s = [1, 2];
+                Diagnostic(ErrorCode.ERR_NoSuchMemberOrExtension, "2").WithArguments("S", "Add").WithLocation(3, 9));
+        }
+
+        [Fact]
+        public void CollectionInitializerType_04()
+        {
+            string source = """
+                C c;
+                c = [];
+                c = [1, 2];
+                class C
+                {
+                    C(object o) { }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (2,5): error CS1729: 'C' does not contain a constructor that takes 0 arguments
+                // c = [];
+                Diagnostic(ErrorCode.ERR_BadCtorArgCount, "[]").WithArguments("C", "0").WithLocation(2, 5),
+                // (2,5): error CS9500: Cannot initialize type 'C' with a collection literal because the type is not constructible.
+                // c = [];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("C").WithLocation(2, 5),
+                // (3,5): error CS1729: 'C' does not contain a constructor that takes 0 arguments
+                // c = [1, 2];
+                Diagnostic(ErrorCode.ERR_BadCtorArgCount, "[1, 2]").WithArguments("C", "0").WithLocation(3, 5),
+                // (3,5): error CS9500: Cannot initialize type 'C' with a collection literal because the type is not constructible.
+                // c = [1, 2];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[1, 2]").WithArguments("C").WithLocation(3, 5));
+        }
+
+        [Fact]
+        public void CollectionInitializerType_05()
+        {
+            string source = """
+                using System.Collections;
+                using System.Collections.Generic;
+                class A : IEnumerable<int>
+                {
+                    A() { }
+                    public void Add(int i) { }
+                    IEnumerator<int> IEnumerable<int>.GetEnumerator() => null;
+                    IEnumerator IEnumerable.GetEnumerator() => null;
+                    static A Create1() => [];
+                }
+                class B
+                {
+                    static A Create2() => [1, 2];
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (13,27): error CS0122: 'A.A()' is inaccessible due to its protection level
+                //     static A Create2() => [1, 2];
+                Diagnostic(ErrorCode.ERR_BadAccess, "[1, 2]").WithArguments("A.A()").WithLocation(13, 27));
+        }
+
+        [Fact]
+        public void CollectionInitializerType_06()
+        {
+            string source = """
+                using System.Collections;
+                using System.Collections.Generic;
+                class C<T> : IEnumerable
+                {
+                    private List<T> _list = new List<T>();
+                    public void Add(T t) { _list.Add(t); }
+                    IEnumerator IEnumerable.GetEnumerator() => _list.GetEnumerator();
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        C<int> c;
+                        object o;
+                        c = [];
+                        o = (C<object>)[];
+                        c.Report();
+                        o.Report();
+                        c = [1, 2];
+                        o = (C<object>)[3, 4];
+                        c.Report();
+                        o.Report();
+                    }
+                }
+                """;
+            CompileAndVerify(new[] { source, GetCollectionExtensions() }, expectedOutput: "[], [], [1, 2], [3, 4], ");
+        }
+
+        [Fact]
+        public void CollectionInitializerType_ConstructorOptionalParameters()
+        {
+            string source = """
+                using System.Collections;
+                using System.Collections.Generic;
+                class C : IEnumerable<int>
+                {
+                    private List<int> _list = new List<int>();
+                    internal C(int x = 1, int y = 2) { }
+                    public void Add(int i) { _list.Add(i); }
+                    IEnumerator<int> IEnumerable<int>.GetEnumerator() => _list.GetEnumerator();
+                    IEnumerator IEnumerable.GetEnumerator() => _list.GetEnumerator();
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        C c;
+                        object o;
+                        c = [];
+                        o = (C)[];
+                        c.Report();
+                        o.Report();
+                        c = [1, 2];
+                        o = (C)[3, 4];
+                        c.Report();
+                        o.Report();
+                    }
+                }
+                """;
+            CompileAndVerify(new[] { source, GetCollectionExtensions() }, expectedOutput: "[], [], [1, 2], [3, 4], ");
+        }
+
+        [Fact]
+        public void CollectionInitializerType_ConstructorParamsArray()
+        {
+            string source = """
+                using System.Collections;
+                using System.Collections.Generic;
+                class C : IEnumerable<int>
+                {
+                    private List<int> _list = new List<int>();
+                    internal C(params int[] args) { }
+                    public void Add(int i) { _list.Add(i); }
+                    IEnumerator<int> IEnumerable<int>.GetEnumerator() => _list.GetEnumerator();
+                    IEnumerator IEnumerable.GetEnumerator() => _list.GetEnumerator();
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        C c;
+                        object o;
+                        c = [];
+                        o = (C)[];
+                        c.Report();
+                        o.Report();
+                        c = [1, 2];
+                        o = (C)[3, 4];
+                        c.Report();
+                        o.Report();
+                    }
+                }
+                """;
+            CompileAndVerify(new[] { source, GetCollectionExtensions() }, expectedOutput: "[], [], [1, 2], [3, 4], ");
+        }
+
+        [Fact]
+        public void CollectionInitializerType_07()
+        {
+            string source = """
+                using System.Collections;
+                using System.Collections.Generic;
+                abstract class A : IEnumerable<int>
+                {
+                    public void Add(int i) { }
+                    IEnumerator<int> IEnumerable<int>.GetEnumerator() => null;
+                    IEnumerator IEnumerable.GetEnumerator() => null;
+                }
+                class B : A { }
+                class Program
+                {
+                    static void Main()
+                    {
+                        A a = [];
+                        B b = [];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (14,15): error CS0144: Cannot create an instance of the abstract type or interface 'A'
+                //         A a = [];
+                Diagnostic(ErrorCode.ERR_NoNewAbstract, "[]").WithArguments("A").WithLocation(14, 15));
+        }
+
+        [Fact]
+        public void CollectionInitializerType_08()
+        {
+            string source = """
+                using System;
+                using System.Collections;
+                using System.Collections.Generic;
+                struct S0<T> : IEnumerable
+                {
+                    public void Add(T t) { }
+                    IEnumerator IEnumerable.GetEnumerator() => throw null;
+                }
+                struct S1<T> : IEnumerable<T>
+                {
+                    public void Add(T t) { }
+                    IEnumerator<T> IEnumerable<T>.GetEnumerator() => throw null;
+                    IEnumerator IEnumerable.GetEnumerator() => throw null;
+                }
+                struct S2<T> : IEnumerable<T>
+                {
+                    public S2() { }
+                    public void Add(T t) { }
+                    IEnumerator<T> IEnumerable<T>.GetEnumerator() => throw null;
+                    IEnumerator IEnumerable.GetEnumerator() => throw null;
+                }
+                class Program
+                {
+                    static void M0()
+                    {
+                        object o = (S0<int>)[];
+                        S0<int> s = [1, 2];
+                    }
+                    static void M1()
+                    {
+                        object o = (S1<int>)[];
+                        S1<int> s = [1, 2];
+                    }
+                    static void M2()
+                    {
+                        S2<int> s = [];
+                        object o = (S2<int>)[1, 2];
+                    }
+                }
+                """;
+            var verifier = CompileAndVerify(source);
+            verifier.VerifyIL("Program.M0", """
+                {
+                  // Code size       35 (0x23)
+                  .maxstack  2
+                  .locals init (S0<int> V_0)
+                  IL_0000:  ldloca.s   V_0
+                  IL_0002:  initobj    "S0<int>"
+                  IL_0008:  ldloc.0
+                  IL_0009:  pop
+                  IL_000a:  ldloca.s   V_0
+                  IL_000c:  initobj    "S0<int>"
+                  IL_0012:  ldloca.s   V_0
+                  IL_0014:  ldc.i4.1
+                  IL_0015:  call       "void S0<int>.Add(int)"
+                  IL_001a:  ldloca.s   V_0
+                  IL_001c:  ldc.i4.2
+                  IL_001d:  call       "void S0<int>.Add(int)"
+                  IL_0022:  ret
+                }
+                """);
+            verifier.VerifyIL("Program.M1", """
+                {
+                  // Code size       35 (0x23)
+                  .maxstack  2
+                  .locals init (S1<int> V_0)
+                  IL_0000:  ldloca.s   V_0
+                  IL_0002:  initobj    "S1<int>"
+                  IL_0008:  ldloc.0
+                  IL_0009:  pop
+                  IL_000a:  ldloca.s   V_0
+                  IL_000c:  initobj    "S1<int>"
+                  IL_0012:  ldloca.s   V_0
+                  IL_0014:  ldc.i4.1
+                  IL_0015:  call       "void S1<int>.Add(int)"
+                  IL_001a:  ldloca.s   V_0
+                  IL_001c:  ldc.i4.2
+                  IL_001d:  call       "void S1<int>.Add(int)"
+                  IL_0022:  ret
+                }
+                """);
+            verifier.VerifyIL("Program.M2", """
+                {
+                  // Code size       30 (0x1e)
+                  .maxstack  2
+                  .locals init (S2<int> V_0)
+                  IL_0000:  newobj     "S2<int>..ctor()"
+                  IL_0005:  pop
+                  IL_0006:  ldloca.s   V_0
+                  IL_0008:  call       "S2<int>..ctor()"
+                  IL_000d:  ldloca.s   V_0
+                  IL_000f:  ldc.i4.1
+                  IL_0010:  call       "void S2<int>.Add(int)"
+                  IL_0015:  ldloca.s   V_0
+                  IL_0017:  ldc.i4.2
+                  IL_0018:  call       "void S2<int>.Add(int)"
+                  IL_001d:  ret
+                }
+                """);
+        }
+
+        [Fact]
+        public void CollectionInitializerType_09()
+        {
+            string source = """
+                using System.Collections;
+                using System.Collections.Generic;
+                class Program
+                {
+                    static void Main()
+                    {
+                        UnknownType u;
+                        u = [];
+                        u = [null, B];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (7,9): error CS0246: The type or namespace name 'UnknownType' could not be found (are you missing a using directive or an assembly reference?)
+                //         UnknownType u;
+                Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "UnknownType").WithArguments("UnknownType").WithLocation(7, 9),
+                // (9,20): error CS0103: The name 'B' does not exist in the current context
+                //         u = [null, B];
+                Diagnostic(ErrorCode.ERR_NameNotInContext, "B").WithArguments("B").WithLocation(9, 20));
+        }
+
+        [Fact]
+        public void CollectionInitializerType_10()
+        {
+            string source = """
+                using System.Collections;
+                using System.Collections.Generic;
+                struct S<T> : IEnumerable<string>
+                {
+                    public void Add(string i) { }
+                    IEnumerator<string> IEnumerable<string>.GetEnumerator() => null;
+                    IEnumerator IEnumerable.GetEnumerator() => null;
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        S<UnknownType> s;
+                        s = [];
+                        s = [null, B];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (13,11): error CS0246: The type or namespace name 'UnknownType' could not be found (are you missing a using directive or an assembly reference?)
+                //         S<UnknownType> s;
+                Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "UnknownType").WithArguments("UnknownType").WithLocation(13, 11),
+                // (15,20): error CS0103: The name 'B' does not exist in the current context
+                //         s = [null, B];
+                Diagnostic(ErrorCode.ERR_NameNotInContext, "B").WithArguments("B").WithLocation(15, 20));
+        }
+
+        [Fact]
+        public void CollectionInitializerType_11()
+        {
+            string source = """
+                using System.Collections.Generic;
+                class Program
+                {
+                    static void Main()
+                    {
+                        List<List<int>> l;
+                        l = [[], [2, 3]];
+                        l = [[], {2, 3}];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (8,18): error CS1003: Syntax error, ']' expected
+                //         l = [[], {2, 3}];
+                Diagnostic(ErrorCode.ERR_SyntaxError, "{").WithArguments("]").WithLocation(8, 18),
+                // (8,18): error CS1002: ; expected
+                //         l = [[], {2, 3}];
+                Diagnostic(ErrorCode.ERR_SemicolonExpected, "{").WithLocation(8, 18),
+                // (8,20): error CS1002: ; expected
+                //         l = [[], {2, 3}];
+                Diagnostic(ErrorCode.ERR_SemicolonExpected, ",").WithLocation(8, 20),
+                // (8,20): error CS1513: } expected
+                //         l = [[], {2, 3}];
+                Diagnostic(ErrorCode.ERR_RbraceExpected, ",").WithLocation(8, 20),
+                // (8,23): error CS1002: ; expected
+                //         l = [[], {2, 3}];
+                Diagnostic(ErrorCode.ERR_SemicolonExpected, "}").WithLocation(8, 23),
+                // (8,24): error CS1513: } expected
+                //         l = [[], {2, 3}];
+                Diagnostic(ErrorCode.ERR_RbraceExpected, "]").WithLocation(8, 24));
+        }
+
+        [Fact]
+        public void CollectionInitializerType_12()
+        {
+            string source = """
+                using System.Collections;
+                using System.Collections.Generic;
+                class C : IEnumerable
+                {
+                    List<string> _list = new List<string>();
+                    public void Add(int i) { _list.Add($"i={i}"); }
+                    public void Add(object o) { _list.Add($"o={o}"); }
+                    IEnumerator IEnumerable.GetEnumerator() => _list.GetEnumerator();
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        C x = [];
+                        C y = [1, (object)2];
+                        x.Report();
+                        y.Report();
+                    }
+                }
+                """;
+            CompileAndVerify(new[] { source, GetCollectionExtensions() }, expectedOutput: "[], [i=1, o=2], ");
+        }
+
+        [Fact]
+        public void CollectionInitializerType_13()
+        {
+            string source = """
+                using System.Collections;
+                interface IA { }
+                interface IB { }
+                class AB : IA, IB { }
+                class C : IEnumerable
+                {
+                    public void Add(IA a) { }
+                    public void Add(IB b) { }
+                    IEnumerator IEnumerable.GetEnumerator() => null;
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        C c = [(IA)null, (IB)null, new AB()];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (15,36): error CS0121: The call is ambiguous between the following methods or properties: 'C.Add(IA)' and 'C.Add(IB)'
+                //         C c = [(IA)null, (IB)null, new AB()];
+                Diagnostic(ErrorCode.ERR_AmbigCall, "new AB()").WithArguments("C.Add(IA)", "C.Add(IB)").WithLocation(15, 36));
+        }
+
+        [Fact]
+        public void CollectionInitializerType_14()
+        {
+            string source = """
+                using System.Collections;
+                struct S<T> : IEnumerable
+                {
+                    public void Add(T x, T y) { }
+                    IEnumerator IEnumerable.GetEnumerator() => throw null;
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        S<int> s;
+                        s = [];
+                        s = [1, 2];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (13,14): error CS7036: There is no argument given that corresponds to the required parameter 'y' of 'S<int>.Add(int, int)'
+                //         s = [1, 2];
+                Diagnostic(ErrorCode.ERR_NoCorrespondingArgument, "1").WithArguments("y", "S<int>.Add(int, int)").WithLocation(13, 14),
+                // (13,17): error CS7036: There is no argument given that corresponds to the required parameter 'y' of 'S<int>.Add(int, int)'
+                //         s = [1, 2];
+                Diagnostic(ErrorCode.ERR_NoCorrespondingArgument, "2").WithArguments("y", "S<int>.Add(int, int)").WithLocation(13, 17));
+        }
+
+        [Fact]
+        public void CollectionInitializerType_15()
+        {
+            string source = """
+                using System.Collections;
+                using System.Collections.Generic;
+                class C<T> : IEnumerable
+                {
+                    List<T> _list = new List<T>();
+                    public void Add(T t, int index = -1) { _list.Add(t); }
+                    IEnumerator IEnumerable.GetEnumerator() => _list.GetEnumerator();
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        C<int> c = [1, 2];
+                        c.Report();
+                    }
+                }
+                """;
+            CompileAndVerify(new[] { source, GetCollectionExtensions() }, expectedOutput: "[1, 2], ");
+        }
+
+        [Fact]
+        public void CollectionInitializerType_16()
+        {
+            string source = """
+                using System.Collections;
+                using System.Collections.Generic;
+                class C<T> : IEnumerable
+                {
+                    List<T> _list = new List<T>();
+                    public void Add(T t, params T[] args) { _list.Add(t); }
+                    IEnumerator IEnumerable.GetEnumerator() => _list.GetEnumerator();
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        C<int> c = [1, 2];
+                        c.Report();
+                    }
+                }
+                """;
+            CompileAndVerify(new[] { source, GetCollectionExtensions() }, expectedOutput: "[1, 2], ");
+        }
+
+        [Fact]
+        public void CollectionInitializerType_17()
+        {
+            string source = """
+                using System.Collections;
+                using System.Collections.Generic;
+                class C<T> : IEnumerable
+                {
+                    List<T> _list = new List<T>();
+                    public void Add(params T[] args) { _list.AddRange(args); }
+                    IEnumerator IEnumerable.GetEnumerator() => _list.GetEnumerator();
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        C<int> c = [[], [1, 2], 3];
+                        c.Report();
+                    }
+                }
+                """;
+            var verifier = CompileAndVerify(new[] { source, GetCollectionExtensions() }, expectedOutput: "[1, 2, 3], ");
+            verifier.VerifyIL("Program.Main", """
+                {
+                  // Code size       61 (0x3d)
+                  .maxstack  5
+                  .locals init (C<int> V_0)
+                  IL_0000:  newobj     "C<int>..ctor()"
+                  IL_0005:  stloc.0
+                  IL_0006:  ldloc.0
+                  IL_0007:  ldc.i4.0
+                  IL_0008:  newarr     "int"
+                  IL_000d:  callvirt   "void C<int>.Add(params int[])"
+                  IL_0012:  ldloc.0
+                  IL_0013:  ldc.i4.2
+                  IL_0014:  newarr     "int"
+                  IL_0019:  dup
+                  IL_001a:  ldc.i4.0
+                  IL_001b:  ldc.i4.1
+                  IL_001c:  stelem.i4
+                  IL_001d:  dup
+                  IL_001e:  ldc.i4.1
+                  IL_001f:  ldc.i4.2
+                  IL_0020:  stelem.i4
+                  IL_0021:  callvirt   "void C<int>.Add(params int[])"
+                  IL_0026:  ldloc.0
+                  IL_0027:  ldc.i4.1
+                  IL_0028:  newarr     "int"
+                  IL_002d:  dup
+                  IL_002e:  ldc.i4.0
+                  IL_002f:  ldc.i4.3
+                  IL_0030:  stelem.i4
+                  IL_0031:  callvirt   "void C<int>.Add(params int[])"
+                  IL_0036:  ldloc.0
+                  IL_0037:  call       "void CollectionExtensions.Report(object)"
+                  IL_003c:  ret
+                }
+                """);
+        }
+
+        [Fact]
+        public void CollectionInitializerType_18()
+        {
+            string source = """
+                using System.Collections;
+                class S<T, U> : IEnumerable
+                {
+                    internal void Add(T t) { }
+                    private void Add(U u) { }
+                    IEnumerator IEnumerable.GetEnumerator() => throw null;
+                    static S<T, U> Create(T t, U u) => [t, u];
+                }
+                class Program
+                {
+                    static S<T, U> Create<T, U>(T x, U y) => [x, y];
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (11,50): error CS1950: The best overloaded Add method 'S<T, U>.Add(T)' for the collection initializer has some invalid arguments
+                //     static S<T, U> Create<T, U>(T x, U y) => [x, y];
+                Diagnostic(ErrorCode.ERR_BadArgTypesForCollectionAdd, "y").WithArguments("S<T, U>.Add(T)").WithLocation(11, 50),
+                // (11,50): error CS1503: Argument 1: cannot convert from 'U' to 'T'
+                //     static S<T, U> Create<T, U>(T x, U y) => [x, y];
+                Diagnostic(ErrorCode.ERR_BadArgType, "y").WithArguments("1", "U", "T").WithLocation(11, 50));
+        }
+
+        [Theory]
+        [InlineData("class")]
+        [InlineData("struct")]
+        public void TypeParameter_01(string type)
+        {
+            string source = $$"""
+                using System;
+                using System.Collections;
+                using System.Collections.Generic;
+                interface I<T> : IEnumerable
+                {
+                    void Add(T t);
+                }
+                {{type}} C<T> : I<T>
+                {
+                    private List<T> _list;
+                    public void Add(T t)
+                    {
+                        GetList().Add(t);
+                    }
+                    IEnumerator IEnumerable.GetEnumerator()
+                    {
+                        return GetList().GetEnumerator();
+                    }
+                    private List<T> GetList() => _list ??= new List<T>();
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        CreateEmpty<C<object>, object>().Report();
+                        Create<C<long?>, long?>(null, 2).Report();
+                    }
+                    static T CreateEmpty<T, U>() where T : I<U>, new()
+                    {
+                        return [];
+                    }
+                    static T Create<T, U>(U a, U b) where T : I<U>, new()
+                    {
+                        return [a, b];
+                    }
+                }
+                """;
+            var verifier = CompileAndVerify(new[] { source, GetCollectionExtensions() }, expectedOutput: "[], [null, 2], ");
+            verifier.VerifyIL("Program.CreateEmpty<T, U>", """
+                {
+                  // Code size        6 (0x6)
+                  .maxstack  1
+                  IL_0000:  call       "T System.Activator.CreateInstance<T>()"
+                  IL_0005:  ret
+                }
+                """);
+            verifier.VerifyIL("Program.Create<T, U>", """
+                {
+                  // Code size       36 (0x24)
+                  .maxstack  2
+                  .locals init (T V_0)
+                  IL_0000:  call       "T System.Activator.CreateInstance<T>()"
+                  IL_0005:  stloc.0
+                  IL_0006:  ldloca.s   V_0
+                  IL_0008:  ldarg.0
+                  IL_0009:  constrained. "T"
+                  IL_000f:  callvirt   "void I<U>.Add(U)"
+                  IL_0014:  ldloca.s   V_0
+                  IL_0016:  ldarg.1
+                  IL_0017:  constrained. "T"
+                  IL_001d:  callvirt   "void I<U>.Add(U)"
+                  IL_0022:  ldloc.0
+                  IL_0023:  ret
+                }
+                """);
+        }
+
+        [Fact]
+        public void TypeParameter_02()
+        {
+            string source = """
+                using System.Collections;
+                using System.Collections.Generic;
+                interface I<T> : IEnumerable<T>
+                {
+                    void Add(T t);
+                }
+                struct S<T> : I<T>
+                {
+                    public void Add(T t) { }
+                    IEnumerator<T> IEnumerable<T>.GetEnumerator() => throw null;
+                    IEnumerator IEnumerable.GetEnumerator() => throw null;
+                }
+                class Program
+                {
+                    static T Create1<T, U>() where T : struct, I<U> => [];
+                    static T? Create2<T, U>() where T : struct, I<U> => [];
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (16,57): error CS9500: Cannot initialize type 'T?' with a collection literal because the type is not constructible.
+                //     static T? Create2<T, U>() where T : struct, I<U> => [];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("T?").WithLocation(16, 57));
+        }
+
+        [Fact]
+        public void TypeParameter_03()
+        {
+            string source = """
+                using System.Collections;
+                class Program
+                {
+                    static T Create1<T, U>() where T : IEnumerable => []; // 1
+                    static T Create2<T, U>() where T : class, IEnumerable => []; // 2
+                    static T Create3<T, U>() where T : struct, IEnumerable => [];
+                    static T Create4<T, U>() where T : IEnumerable, new() => [];
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (4,55): error CS0304: Cannot create an instance of the variable type 'T' because it does not have the new() constraint
+                //     static T Create1<T, U>() where T : IEnumerable => []; // 1
+                Diagnostic(ErrorCode.ERR_NoNewTyvar, "[]").WithArguments("T").WithLocation(4, 55),
+                // (5,62): error CS0304: Cannot create an instance of the variable type 'T' because it does not have the new() constraint
+                //     static T Create2<T, U>() where T : class, IEnumerable => []; // 2
+                Diagnostic(ErrorCode.ERR_NoNewTyvar, "[]").WithArguments("T").WithLocation(5, 62));
+        }
+
+        [Fact]
+        public void TypeParameter_04()
+        {
+            string source = """
+                using System.Collections;
+                interface IAdd : IEnumerable
+                {
+                    void Add(int i);
+                }
+                class Program
+                {
+                    static T Create1<T>() where T : IAdd => [1]; // 1
+                    static T Create2<T>() where T : class, IAdd => [2]; // 2
+                    static T Create3<T>() where T : struct, IAdd => [3];
+                    static T Create4<T>() where T : IAdd, new() => [4];
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (8,45): error CS0304: Cannot create an instance of the variable type 'T' because it does not have the new() constraint
+                //     static T Create1<T>() where T : IAdd => [1]; // 1
+                Diagnostic(ErrorCode.ERR_NoNewTyvar, "[1]").WithArguments("T").WithLocation(8, 45),
+                // (9,52): error CS0304: Cannot create an instance of the variable type 'T' because it does not have the new() constraint
+                //     static T Create2<T>() where T : class, IAdd => [2]; // 2
+                Diagnostic(ErrorCode.ERR_NoNewTyvar, "[2]").WithArguments("T").WithLocation(9, 52));
+        }
+
+        [Fact]
+        public void CollectionInitializerType_MissingIEnumerable()
+        {
+            string source = """
+                struct S
+                {
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        S s = [];
+                        object o = (S)[1, 2];
+                    }
+                }
+                """;
+
+            var comp = CreateCompilation(source);
+            comp.MakeTypeMissing(SpecialType.System_Collections_IEnumerable);
+            comp.VerifyEmitDiagnostics(
+                // (8,15): error CS0518: Predefined type 'System.Collections.IEnumerable' is not defined or imported
+                //         S s = [];
+                Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "[]").WithArguments("System.Collections.IEnumerable").WithLocation(8, 15),
+                // (8,15): error CS9500: Cannot initialize type 'S' with a collection literal because the type is not constructible.
+                //         S s = [];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("S").WithLocation(8, 15),
+                // (9,23): error CS0518: Predefined type 'System.Collections.IEnumerable' is not defined or imported
+                //         object o = (S)[1, 2];
+                Diagnostic(ErrorCode.ERR_PredefinedTypeNotFound, "[1, 2]").WithArguments("System.Collections.IEnumerable").WithLocation(9, 23),
+                // (9,23): error CS9500: Cannot initialize type 'S' with a collection literal because the type is not constructible.
+                //         object o = (S)[1, 2];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[1, 2]").WithArguments("S").WithLocation(9, 23));
+        }
+
+        [Fact]
+        public void CollectionInitializerType_UseSiteErrors()
+        {
+            string assemblyA = GetUniqueName();
+            string sourceA = """
+                public class A1 { }
+                public class A2 { }
+                """;
+            var comp = CreateCompilation(sourceA, assemblyName: assemblyA);
+            var refA = comp.EmitToImageReference();
+
+            string sourceB = """
+                using System.Collections;
+                using System.Collections.Generic;
+                public class B1 : IEnumerable
+                {
+                    List<int> _list = new List<int>();
+                    public B1(A1 a = null) { }
+                    public void Add(int i) { _list.Add(i); }
+                    IEnumerator IEnumerable.GetEnumerator() => _list.GetEnumerator();
+                }
+                public class B2 : IEnumerable
+                {
+                    List<int> _list = new List<int>();
+                    public void Add(int x, A2 y = null) { _list.Add(x); }
+                    IEnumerator IEnumerable.GetEnumerator() => _list.GetEnumerator();
+                }
+                """;
+            comp = CreateCompilation(sourceB, references: new[] { refA });
+            var refB = comp.EmitToImageReference();
+
+            string sourceC = """
+                class C
+                {
+                    static void Main()
+                    {
+                        B1 x;
+                        x = [];
+                        x.Report();
+                        x = [1, 2];
+                        x.Report();
+                        B2 y;
+                        y = [];
+                        y.Report();
+                        y = [3, 4];
+                        y.Report();
+                    }
+                }
+                """;
+            CompileAndVerify(new[] { sourceC, GetCollectionExtensions() }, references: new[] { refA, refB }, expectedOutput: "[], [1, 2], [], [3, 4], ");
+
+            comp = CreateCompilation(new[] { sourceC, GetCollectionExtensions() }, references: new[] { refB });
+            comp.VerifyEmitDiagnostics(
+                // (6,13): error CS0012: The type 'A1' is defined in an assembly that is not referenced. You must add a reference to assembly 'a897d975-a839-4fff-828b-deccf9495adc, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'.
+                //         x = [];
+                Diagnostic(ErrorCode.ERR_NoTypeDef, "[]").WithArguments("A1", $"{assemblyA}, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null").WithLocation(6, 13),
+                // (8,13): error CS0012: The type 'A1' is defined in an assembly that is not referenced. You must add a reference to assembly 'a897d975-a839-4fff-828b-deccf9495adc, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'.
+                //         x = [1, 2];
+                Diagnostic(ErrorCode.ERR_NoTypeDef, "[1, 2]").WithArguments("A1", $"{assemblyA}, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null").WithLocation(8, 13),
+                // (13,14): error CS0012: The type 'A2' is defined in an assembly that is not referenced. You must add a reference to assembly 'a897d975-a839-4fff-828b-deccf9495adc, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'.
+                //         y = [3, 4];
+                Diagnostic(ErrorCode.ERR_NoTypeDef, "3").WithArguments("A2", $"{assemblyA}, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null").WithLocation(13, 14),
+                // (13,17): error CS0012: The type 'A2' is defined in an assembly that is not referenced. You must add a reference to assembly 'a897d975-a839-4fff-828b-deccf9495adc, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null'.
+                //         y = [3, 4];
+                Diagnostic(ErrorCode.ERR_NoTypeDef, "4").WithArguments("A2", $"{assemblyA}, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null").WithLocation(13, 17));
+        }
+
+        [Fact]
+        public void DictionaryElement_01()
+        {
+            string source = """
+                using System.Collections.Generic;
+                class Program
+                {
+                    static void Main()
+                    {
+                        Dictionary<int, int> d;
+                        d = [];
+                        d = [new KeyValuePair<int, int>(1, 2)];
+                        d = [3:4];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (8,14): error CS7036: There is no argument given that corresponds to the required parameter 'value' of 'Dictionary<int, int>.Add(int, int)'
+                //         d = [new KeyValuePair<int, int>(1, 2)];
+                Diagnostic(ErrorCode.ERR_NoCorrespondingArgument, "new KeyValuePair<int, int>(1, 2)").WithArguments("value", "System.Collections.Generic.Dictionary<int, int>.Add(int, int)").WithLocation(8, 14),
+                // (9,14): error CS9502: Support for collection literal dictionary and spread elements has not been implemented.
+                //         d = [3:4];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralElementNotImplemented, "3:4").WithLocation(9, 14));
+        }
+
+        [Fact]
+        public void SpreadElement_01()
+        {
+            string source = """
+                class Program
+                {
+                    static void Main()
+                    {
+                        int[] a;
+                        a = [];
+                        a = [..a, ..[1, 2]];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (7,14): error CS9502: Support for collection literal dictionary and spread elements has not been implemented.
+                //         a = [..a, ..[1, 2]];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralElementNotImplemented, "..a").WithLocation(7, 14),
+                // (7,19): error CS9502: Support for collection literal dictionary and spread elements has not been implemented.
+                //         a = [..a, ..[1, 2]];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralElementNotImplemented, "..[1, 2]").WithLocation(7, 19));
+        }
+
+        [Fact]
+        public void Nullable_01()
+        {
+            string source = """
+                #nullable enable
+                class Program
+                {
+                    static void Main()
+                    {
+                        object?[] x = [1];
+                        x[0].ToString(); // 1
+                        object[] y = [null]; // 2
+                        y[0].ToString();
+                        y = [2, null]; // 3
+                        y[1].ToString();
+                        object[]? z = [];
+                        z.ToString();
+                        z = [3];
+                        z.ToString();
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            // PROTOTYPE: // 2 should be reported as a warning (compare with array initializer: new object[] { null }).
+            comp.VerifyEmitDiagnostics(
+                // (7,9): warning CS8602: Dereference of a possibly null reference.
+                //         x[0].ToString(); // 1
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "x[0]").WithLocation(7, 9));
+        }
+
+        [Fact]
+        public void Nullable_02()
+        {
+            string source = """
+                #nullable enable
+                using System.Collections.Generic;
+                class Program
+                {
+                    static void Main()
+                    {
+                        List<object?> x = [1];
+                        x[0].ToString(); // 1
+                        List<object> y = [null]; // 2
+                        y[0].ToString();
+                        y = [2, null]; // 3
+                        y[1].ToString();
+                        List<object>? z = [];
+                        z.ToString();
+                        z = [3];
+                        z.ToString();
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (8,9): warning CS8602: Dereference of a possibly null reference.
+                //         x[0].ToString(); // 1
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "x[0]").WithLocation(8, 9),
+                // (9,27): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         List<object> y = [null]; // 2
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(9, 27),
+                // (11,17): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         y = [2, null]; // 3
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(11, 17));
+        }
+
+        [Fact]
+        public void Nullable_03()
+        {
+            string source = """
+                #nullable enable
+                using System.Collections;
+                struct S<T> : IEnumerable
+                {
+                    public void Add(T t) { }
+                    public T this[int index] => default!;
+                    IEnumerator IEnumerable.GetEnumerator() => default!;
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        S<object?> x = [1];
+                        x[0].ToString(); // 1
+                        S<object> y = [null]; // 2
+                        y[0].ToString();
+                        y = [2, null]; // 3
+                        y[1].ToString();
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (14,9): warning CS8602: Dereference of a possibly null reference.
+                //         x[0].ToString(); // 1
+                Diagnostic(ErrorCode.WRN_NullReferenceReceiver, "x[0]").WithLocation(14, 9),
+                // (15,24): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         S<object> y = [null]; // 2
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(15, 24),
+                // (17,17): warning CS8625: Cannot convert null literal to non-nullable reference type.
+                //         y = [2, null]; // 3
+                Diagnostic(ErrorCode.WRN_NullAsNonNullable, "null").WithLocation(17, 17));
+        }
+
+        [Fact]
+        public void Nullable_04()
+        {
+            string source = """
+                #nullable enable
+                using System.Collections;
+                struct S<T> : IEnumerable
+                {
+                    public void Add(T t) { }
+                    public T this[int index] => default!;
+                    IEnumerator IEnumerable.GetEnumerator() => default!;
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        S<object>? x = [];
+                        x = [];
+                        S<object>? y = [1];
+                        y = [2];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (13,24): error CS9500: Cannot initialize type 'S<object>?' with a collection literal because the type is not constructible.
+                //         S<object>? x = [];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("S<object>?").WithLocation(13, 24),
+                // (14,13): error CS9500: Cannot initialize type 'S<object>?' with a collection literal because the type is not constructible.
+                //         x = [];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("S<object>?").WithLocation(14, 13),
+                // (15,24): error CS9500: Cannot initialize type 'S<object>?' with a collection literal because the type is not constructible.
+                //         S<object>? y = [1];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[1]").WithArguments("S<object>?").WithLocation(15, 24),
+                // (16,13): error CS9500: Cannot initialize type 'S<object>?' with a collection literal because the type is not constructible.
+                //         y = [2];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[2]").WithArguments("S<object>?").WithLocation(16, 13));
+        }
+
+        [Fact]
+        public void OrderOfEvaluation()
+        {
+            string source = """
+                using System;
+                using System.Collections;
+                using System.Collections.Generic;
+                class C<T> : IEnumerable
+                {
+                    private List<T> _list = new List<T>();
+                    public void Add(T t)
+                    {
+                        Console.WriteLine("Add {0}", t);
+                        _list.Add(t);
+                    }
+                    IEnumerator IEnumerable.GetEnumerator() => _list.GetEnumerator();
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        C<int> x = [Get(1), Get(2)];
+                        C<C<int>> y = [[Get(3)], [Get(4), Get(5)]];
+                    }
+                    static int Get(int value)
+                    {
+                        Console.WriteLine("Get {0}", value);
+                        return value;
+                    }
+                }
+                """;
+            CompileAndVerify(source, expectedOutput: """
+                Get 1
+                Add 1
+                Get 2
+                Add 2
+                Get 3
+                Add 3
+                Add C`1[System.Int32]
+                Get 4
+                Add 4
+                Get 5
+                Add 5
+                Add C`1[System.Int32]
+                """);
+        }
+
+        // Ensure collection literal conversions are not standard implicit conversions
+        // and, as a result, are ignored when determining user-defined conversions.
+        [Fact]
+        public void UserDefinedConversions_01()
+        {
+            string source = """
+                struct S
+                {
+                    public static implicit operator S(int[] a) => default;
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        S s = [];
+                        s = [1, 2];
+                        s = (S)[3, 4];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (9,15): error CS9500: Cannot initialize type 'S' with a collection literal because the type is not constructible.
+                //         S s = [];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("S").WithLocation(9, 15),
+                // (10,13): error CS9500: Cannot initialize type 'S' with a collection literal because the type is not constructible.
+                //         s = [1, 2];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[1, 2]").WithArguments("S").WithLocation(10, 13),
+                // (11,16): error CS9500: Cannot initialize type 'S' with a collection literal because the type is not constructible.
+                //         s = (S)[3, 4];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[3, 4]").WithArguments("S").WithLocation(11, 16));
+        }
+
+        [Fact]
+        public void UserDefinedConversions_02()
+        {
+            string source = """
+                struct S
+                {
+                    public static explicit operator S(int[] a) => default;
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        S s = [];
+                        s = [1, 2];
+                        s = (S)[3, 4];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (9,15): error CS9500: Cannot initialize type 'S' with a collection literal because the type is not constructible.
+                //         S s = [];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("S").WithLocation(9, 15),
+                // (10,13): error CS9500: Cannot initialize type 'S' with a collection literal because the type is not constructible.
+                //         s = [1, 2];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[1, 2]").WithArguments("S").WithLocation(10, 13),
+                // (11,16): error CS9500: Cannot initialize type 'S' with a collection literal because the type is not constructible.
+                //         s = (S)[3, 4];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[3, 4]").WithArguments("S").WithLocation(11, 16));
+        }
+
+        [Fact]
+        public void PrimaryConstructorParameters_01()
+        {
+            string source = """
+                struct S(int x, int y, int z)
+                {
+                    int[] F = [x, y];
+                    int[] M() => [y];
+                    static void Main()
+                    {
+                        var s = new S(1, 2, 3);
+                        s.F.Report();
+                        s.M().Report();
+                    }
+                }
+                """;
+
+            var comp = CreateCompilation(new[] { source, GetCollectionExtensions() }, options: TestOptions.ReleaseExe);
+            comp.VerifyEmitDiagnostics(
+                // 0.cs(1,28): warning CS9113: Parameter 'z' is unread.
+                // struct S(int x, int y, int z)
+                Diagnostic(ErrorCode.WRN_UnreadPrimaryConstructorParameter, "z").WithArguments("z").WithLocation(1, 28));
+
+            var verifier = CompileAndVerify(comp, expectedOutput: "[1, 2], [2], ");
+            verifier.VerifyIL("S..ctor(int, int, int)",
+                """
+                {
+                  // Code size       33 (0x21)
+                  .maxstack  5
+                  IL_0000:  ldarg.0
+                  IL_0001:  ldarg.2
+                  IL_0002:  stfld      "int S.<y>PC__BackingField"
+                  IL_0007:  ldarg.0
+                  IL_0008:  ldc.i4.2
+                  IL_0009:  newarr     "int"
+                  IL_000e:  dup
+                  IL_000f:  ldc.i4.0
+                  IL_0010:  ldarg.1
+                  IL_0011:  stelem.i4
+                  IL_0012:  dup
+                  IL_0013:  ldc.i4.1
+                  IL_0014:  ldarg.0
+                  IL_0015:  ldfld      "int S.<y>PC__BackingField"
+                  IL_001a:  stelem.i4
+                  IL_001b:  stfld      "int[] S.F"
+                  IL_0020:  ret
+                }
+                """);
+        }
+
+        [Fact]
+        public void PrimaryConstructorParameters_02()
+        {
+            string source = """
+                using System;
+                class C(int x, int y, int z)
+                {
+                    Func<int[]> F = () => [x, y];
+                    Func<int[]> M() => () => [y];
+                    static void Main()
+                    {
+                        var c = new C(1, 2, 3);
+                        c.F().Report();
+                        c.M()().Report();
+                    }
+                }
+                """;
+
+            var comp = CreateCompilation(new[] { source, GetCollectionExtensions() }, options: TestOptions.ReleaseExe);
+            comp.VerifyEmitDiagnostics(
+                // 0.cs(2,27): warning CS9113: Parameter 'z' is unread.
+                // class C(int x, int y, int z)
+                Diagnostic(ErrorCode.WRN_UnreadPrimaryConstructorParameter, "z").WithArguments("z").WithLocation(2, 27));
+
+            var verifier = CompileAndVerify(comp, verify: Verification.Fails, expectedOutput: "[1, 2], [2], ");
+            verifier.VerifyIL("C..ctor(int, int, int)",
+                """
+                {
+                  // Code size       52 (0x34)
+                  .maxstack  3
+                  .locals init (C.<>c__DisplayClass0_0 V_0) //CS$<>8__locals0
+                  IL_0000:  ldarg.0
+                  IL_0001:  ldarg.2
+                  IL_0002:  stfld      "int C.<y>PC__BackingField"
+                  IL_0007:  newobj     "C.<>c__DisplayClass0_0..ctor()"
+                  IL_000c:  stloc.0
+                  IL_000d:  ldloc.0
+                  IL_000e:  ldarg.1
+                  IL_000f:  stfld      "int C.<>c__DisplayClass0_0.x"
+                  IL_0014:  ldloc.0
+                  IL_0015:  ldarg.0
+                  IL_0016:  stfld      "C C.<>c__DisplayClass0_0.<>4__this"
+                  IL_001b:  ldarg.0
+                  IL_001c:  ldloc.0
+                  IL_001d:  ldftn      "int[] C.<>c__DisplayClass0_0.<.ctor>b__0()"
+                  IL_0023:  newobj     "System.Func<int[]>..ctor(object, System.IntPtr)"
+                  IL_0028:  stfld      "System.Func<int[]> C.F"
+                  IL_002d:  ldarg.0
+                  IL_002e:  call       "object..ctor()"
+                  IL_0033:  ret
+                }
+                """);
+        }
+
+        [Fact]
+        public void PrimaryConstructorParameters_03()
+        {
+            string source = """
+                using System.Collections.Generic;
+                class A(int[] x, List<int> y)
+                {
+                    public int[] X = x;
+                    public List<int> Y = y;
+                }
+                class B(int x, int y, int z) : A([y, z], [z])
+                {
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        var b = new B(1, 2, 3);
+                        b.X.Report();
+                        b.Y.Report();
+                    }
+                }
+                """;
+
+            var comp = CreateCompilation(new[] { source, GetCollectionExtensions() }, options: TestOptions.ReleaseExe);
+            comp.VerifyEmitDiagnostics(
+                // 0.cs(7,13): warning CS9113: Parameter 'x' is unread.
+                // class B(int x, int y, int z) : A([y, z], [z])
+                Diagnostic(ErrorCode.WRN_UnreadPrimaryConstructorParameter, "x").WithArguments("x").WithLocation(7, 13));
+
+            var verifier = CompileAndVerify(comp, expectedOutput: "[2, 3], [3], ");
+            verifier.VerifyIL("B..ctor(int, int, int)",
+                """
+                {
+                  // Code size       33 (0x21)
+                  .maxstack  5
+                  IL_0000:  ldarg.0
+                  IL_0001:  ldc.i4.2
+                  IL_0002:  newarr     "int"
+                  IL_0007:  dup
+                  IL_0008:  ldc.i4.0
+                  IL_0009:  ldarg.2
+                  IL_000a:  stelem.i4
+                  IL_000b:  dup
+                  IL_000c:  ldc.i4.1
+                  IL_000d:  ldarg.3
+                  IL_000e:  stelem.i4
+                  IL_000f:  newobj     "System.Collections.Generic.List<int>..ctor()"
+                  IL_0014:  dup
+                  IL_0015:  ldarg.3
+                  IL_0016:  callvirt   "void System.Collections.Generic.List<int>.Add(int)"
+                  IL_001b:  call       "A..ctor(int[], System.Collections.Generic.List<int>)"
+                  IL_0020:  ret
+                }
+                """);
+        }
+
+        [ConditionalFact(typeof(CoreClrOnly))]
+        public void SemanticModel()
+        {
+            string source = """
+                using System;
+                using System.Collections;
+                using System.Collections.Generic;
+                struct S1 : IEnumerable
+                {
+                    IEnumerator IEnumerable.GetEnumerator() => throw null;
+                }
+                struct S2
+                {
+                }
+                class Program
+                {
+                    static void Main()
+                    {
+                        int[] v1 = [];
+                        List<object> v2 = [];
+                        Span<int> v3 = [];
+                        ReadOnlySpan<object> v4 = [];
+                        S1 v5 = [];
+                        S2 v6 = [];
+                        var v7 = (int[])[];
+                        var v8 = (List<object>)[];
+                        var v9 = (Span<int>)[];
+                        var v10 = (ReadOnlySpan<object>)[];
+                        var v11 = (S1)[];
+                        var v12 = (S2)[];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source, targetFramework: TargetFramework.Net70);
+            comp.VerifyEmitDiagnostics(
+                // (20,17): error CS9500: Cannot initialize type 'S2' with a collection literal because the type is not constructible.
+                //         S2 v6 = [];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("S2").WithLocation(20, 17),
+                // (26,23): error CS9500: Cannot initialize type 'S2' with a collection literal because the type is not constructible.
+                //         var v12 = (S2)[];
+                Diagnostic(ErrorCode.ERR_CollectionLiteralTargetTypeNotConstructible, "[]").WithArguments("S2").WithLocation(26, 23));
+
+            var tree = comp.SyntaxTrees[0];
+            var model = comp.GetSemanticModel(tree);
+            var collections = tree.GetRoot().DescendantNodes().OfType<CollectionCreationExpressionSyntax>().ToArray();
+            Assert.Equal(12, collections.Length);
+            verifyTypes(collections[0], "System.Int32[]", ConversionKind.CollectionLiteral);
+            verifyTypes(collections[1], "System.Collections.Generic.List<System.Object>", ConversionKind.CollectionLiteral);
+            verifyTypes(collections[2], "System.Span<System.Int32>", ConversionKind.CollectionLiteral);
+            verifyTypes(collections[3], "System.ReadOnlySpan<System.Object>", ConversionKind.CollectionLiteral);
+            verifyTypes(collections[4], "S1", ConversionKind.CollectionLiteral);
+            verifyTypes(collections[5], "S2", ConversionKind.CollectionLiteral);
+            verifyTypes(collections[6], "System.Int32[]", ConversionKind.CollectionLiteral);
+            verifyTypes(collections[7], "System.Collections.Generic.List<System.Object>", ConversionKind.CollectionLiteral);
+            verifyTypes(collections[8], "System.Span<System.Int32>", ConversionKind.CollectionLiteral);
+            verifyTypes(collections[9], "System.ReadOnlySpan<System.Object>", ConversionKind.CollectionLiteral);
+            verifyTypes(collections[10], "S1", ConversionKind.CollectionLiteral);
+            verifyTypes(collections[11], "S2", ConversionKind.CollectionLiteral);
+
+            void verifyTypes(ExpressionSyntax expr, string expectedConvertedType, ConversionKind expectedConversionKind)
+            {
+                var typeInfo = model.GetTypeInfo(expr);
+                var conversion = model.GetConversion(expr);
+                Assert.Null(typeInfo.Type);
+                Assert.Equal(expectedConvertedType, typeInfo.ConvertedType.ToTestDisplayString());
+                Assert.Equal(expectedConversionKind, conversion.Kind);
+            }
+        }
+
+        [ConditionalFact(typeof(DesktopOnly))]
+        public void RestrictedTypes_01()
+        {
+            string source = """
+                using System;
+                class Program
+                {
+                    static void Main()
+                    {
+                        var x = [default(TypedReference)];
+                        var y = [default(ArgIterator)];
+                        var z = [default(RuntimeArgumentHandle)];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (6,13): error CS0815: Cannot assign collection literals to an implicitly-typed variable
+                //         var x = [default(TypedReference)];
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedVariableAssignedBadValue, "x = [default(TypedReference)]").WithArguments("collection literals").WithLocation(6, 13),
+                // (7,13): error CS0815: Cannot assign collection literals to an implicitly-typed variable
+                //         var y = [default(ArgIterator)];
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedVariableAssignedBadValue, "y = [default(ArgIterator)]").WithArguments("collection literals").WithLocation(7, 13),
+                // (8,13): error CS0815: Cannot assign collection literals to an implicitly-typed variable
+                //         var z = [default(RuntimeArgumentHandle)];
+                Diagnostic(ErrorCode.ERR_ImplicitlyTypedVariableAssignedBadValue, "z = [default(RuntimeArgumentHandle)]").WithArguments("collection literals").WithLocation(8, 13));
+        }
+
+        [ConditionalFact(typeof(DesktopOnly))]
+        public void RestrictedTypes_02()
+        {
+            string source = """
+                using System;
+                class Program
+                {
+                    static void Main()
+                    {
+                        UnknownType u;
+                        u = [default(TypedReference)];
+                        u = [default(ArgIterator)];
+                        u = [default(RuntimeArgumentHandle)];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            // PROTOTYPE: Should report errors for restricted types.
+            comp.VerifyEmitDiagnostics(
+                // (6,9): error CS0246: The type or namespace name 'UnknownType' could not be found (are you missing a using directive or an assembly reference?)
+                //         UnknownType u;
+                Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "UnknownType").WithArguments("UnknownType").WithLocation(6, 9));
+        }
+
+        [Fact]
+        public void ExpressionTrees()
+        {
+            string source = """
+                using System;
+                using System.Collections;
+                using System.Collections.Generic;
+                using System.Linq.Expressions;
+                interface I<T> : IEnumerable
+                {
+                    void Add(T t);
+                }
+                class Program
+                {
+                    static Expression<Func<int[]>> Create1()
+                    {
+                        return () => [];
+                    }
+                    static Expression<Func<List<object>>> Create2()
+                    {
+                        return () => [1, 2];
+                    }
+                    static Expression<Func<T>> Create3<T, U>(U a, U b) where T : I<U>, new()
+                    {
+                        return () => [a, b];
+                    }
+                }
+                """;
+            var comp = CreateCompilation(source);
+            comp.VerifyEmitDiagnostics(
+                // (13,22): error CS9501: An expression tree may not contain a collection literal.
+                //         return () => [];
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsCollectionLiteral, "[]").WithLocation(13, 22),
+                // (17,22): error CS9501: An expression tree may not contain a collection literal.
+                //         return () => [1, 2];
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsCollectionLiteral, "[1, 2]").WithLocation(17, 22),
+                // (21,22): error CS9501: An expression tree may not contain a collection literal.
+                //         return () => [a, b];
+                Diagnostic(ErrorCode.ERR_ExpressionTreeContainsCollectionLiteral, "[a, b]").WithLocation(21, 22));
+        }
+
+        [Fact]
+        public void IOperation_Array()
+        {
+            string source = """
+                class Program
+                {
+                    static T[] Create<T>(T a, T b)
+                    {
+                        return /*<bind>*/[a, b]/*</bind>*/;
+                    }
+                }
+                """;
+
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics();
+
+            VerifyOperationTreeForTest<CollectionCreationExpressionSyntax>(comp,
+@"IArrayCreationOperation (OperationKind.ArrayCreation, Type: T[]) (Syntax: '[a, b]')
+  Dimension Sizes(1):
+      ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 2, IsImplicit) (Syntax: '[a, b]')
+  Initializer:
+    IArrayInitializerOperation (2 elements) (OperationKind.ArrayInitializer, Type: null, IsImplicit) (Syntax: '[a, b]')
+      Element Values(2):
+          IParameterReferenceOperation: a (OperationKind.ParameterReference, Type: T, IsImplicit) (Syntax: 'a')
+          IParameterReferenceOperation: b (OperationKind.ParameterReference, Type: T, IsImplicit) (Syntax: 'b')
+");
+
+            var tree = comp.SyntaxTrees[0];
+            var method = tree.GetRoot().DescendantNodes().OfType<MethodDeclarationSyntax>().Single(m => m.Identifier.Text == "Create");
+            VerifyFlowGraph(comp, method,
+@"Block[B0] - Entry
+    Statements (0)
+    Next (Regular) Block[B1]
+Block[B1] - Block
+    Predecessors: [B0]
+    Statements (0)
+    Next (Return) Block[B2]
+        IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: T[], IsImplicit) (Syntax: '[a, b]')
+          Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+            (CollectionLiteral)
+          Operand:
+            IArrayCreationOperation (OperationKind.ArrayCreation, Type: T[]) (Syntax: '[a, b]')
+              Dimension Sizes(1):
+                  ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 2, IsImplicit) (Syntax: '[a, b]')
+              Initializer:
+                IArrayInitializerOperation (2 elements) (OperationKind.ArrayInitializer, Type: null, IsImplicit) (Syntax: '[a, b]')
+                  Element Values(2):
+                      IParameterReferenceOperation: a (OperationKind.ParameterReference, Type: T, IsImplicit) (Syntax: 'a')
+                      IParameterReferenceOperation: b (OperationKind.ParameterReference, Type: T, IsImplicit) (Syntax: 'b')
+Block[B2] - Exit
+    Predecessors: [B1]
+    Statements (0)
+");
+        }
+
+        [ConditionalFact(typeof(CoreClrOnly))]
+        public void IOperation_Span()
+        {
+            string source = """
+                using System;
+                class Program
+                {
+                    static Span<T> Create<T>(T a, T b)
+                    {
+                        return /*<bind>*/[a, b]/*</bind>*/;
+                    }
+                }
+                """;
+
+            var comp = CreateCompilation(source, targetFramework: TargetFramework.Net70);
+            comp.VerifyDiagnostics();
+
+            VerifyOperationTreeForTest<CollectionCreationExpressionSyntax>(comp,
+@"IObjectCreationOperation (Constructor: System.Span<T>..ctor(T[]? array)) (OperationKind.ObjectCreation, Type: System.Span<T>) (Syntax: '[a, b]')
+  Arguments(1):
+      IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: array) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: '[a, b]')
+        IArrayCreationOperation (OperationKind.ArrayCreation, Type: T[]?, IsImplicit) (Syntax: '[a, b]')
+          Dimension Sizes(1):
+              ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 2, IsImplicit) (Syntax: '[a, b]')
+          Initializer:
+            IArrayInitializerOperation (2 elements) (OperationKind.ArrayInitializer, Type: null, IsImplicit) (Syntax: '[a, b]')
+              Element Values(2):
+                  IParameterReferenceOperation: a (OperationKind.ParameterReference, Type: T, IsImplicit) (Syntax: 'a')
+                  IParameterReferenceOperation: b (OperationKind.ParameterReference, Type: T, IsImplicit) (Syntax: 'b')
+        InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+        OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+  Initializer:
+    null
+");
+
+            var tree = comp.SyntaxTrees[0];
+            var method = tree.GetRoot().DescendantNodes().OfType<MethodDeclarationSyntax>().Single(m => m.Identifier.Text == "Create");
+            VerifyFlowGraph(comp, method,
+@"Block[B0] - Entry
+    Statements (0)
+    Next (Regular) Block[B1]
+Block[B1] - Block
+    Predecessors: [B0]
+    Statements (0)
+    Next (Return) Block[B2]
+        IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Span<T>, IsImplicit) (Syntax: '[a, b]')
+          Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+            (CollectionLiteral)
+          Operand:
+            IObjectCreationOperation (Constructor: System.Span<T>..ctor(T[]? array)) (OperationKind.ObjectCreation, Type: System.Span<T>) (Syntax: '[a, b]')
+              Arguments(1):
+                  IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: array) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: '[a, b]')
+                    IArrayCreationOperation (OperationKind.ArrayCreation, Type: T[]?, IsImplicit) (Syntax: '[a, b]')
+                      Dimension Sizes(1):
+                          ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 2, IsImplicit) (Syntax: '[a, b]')
+                      Initializer:
+                        IArrayInitializerOperation (2 elements) (OperationKind.ArrayInitializer, Type: null, IsImplicit) (Syntax: '[a, b]')
+                          Element Values(2):
+                              IParameterReferenceOperation: a (OperationKind.ParameterReference, Type: T, IsImplicit) (Syntax: 'a')
+                              IParameterReferenceOperation: b (OperationKind.ParameterReference, Type: T, IsImplicit) (Syntax: 'b')
+                    InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                    OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+              Initializer:
+                null
+Block[B2] - Exit
+    Predecessors: [B1]
+    Statements (0)
+");
+        }
+
+        [Fact]
+        public void IOperation_CollectionInitializer()
+        {
+            string source = """
+                using System.Collections;
+                using System.Collections.Generic;
+                interface I<T> : IEnumerable<T>
+                {
+                    void Add(T t);
+                }
+                struct S<T> : I<T>
+                {
+                    public void Add(T t) { }
+                    IEnumerator<T> IEnumerable<T>.GetEnumerator() => throw null;
+                    IEnumerator IEnumerable.GetEnumerator() => throw null;
+                }
+                class Program
+                {
+                    static S<T> Create<T>(T a, T b)
+                    {
+                        return /*<bind>*/[a, b]/*</bind>*/;
+                    }
+                }
+                """;
+
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics();
+
+            VerifyOperationTreeForTest<CollectionCreationExpressionSyntax>(comp,
+@"IObjectCreationOperation (Constructor: S<T>..ctor()) (OperationKind.ObjectCreation, Type: S<T>) (Syntax: '[a, b]')
+  Arguments(0)
+  Initializer:
+    IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: S<T>, IsImplicit) (Syntax: '[a, b]')
+      Initializers(2):
+          IInvocationOperation ( void S<T>.Add(T t)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'a')
+            Instance Receiver:
+              IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: S<T>, IsImplicit) (Syntax: '[a, b]')
+            Arguments(1):
+                IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: t) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'a')
+                  IParameterReferenceOperation: a (OperationKind.ParameterReference, Type: T) (Syntax: 'a')
+                  InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+          IInvocationOperation ( void S<T>.Add(T t)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'b')
+            Instance Receiver:
+              IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: S<T>, IsImplicit) (Syntax: '[a, b]')
+            Arguments(1):
+                IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: t) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'b')
+                  IParameterReferenceOperation: b (OperationKind.ParameterReference, Type: T) (Syntax: 'b')
+                  InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+");
+
+            var tree = comp.SyntaxTrees[0];
+            var method = tree.GetRoot().DescendantNodes().OfType<MethodDeclarationSyntax>().Single(m => m.Identifier.Text == "Create");
+            VerifyFlowGraph(comp, method,
+@"Block[B0] - Entry
+    Statements (0)
+    Next (Regular) Block[B1]
+        Entering: {R1}
+.locals {R1}
+{
+    CaptureIds: [0]
+    Block[B1] - Block
+        Predecessors: [B0]
+        Statements (3)
+            IFlowCaptureOperation: 0 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: '[a, b]')
+              Value:
+                IObjectCreationOperation (Constructor: S<T>..ctor()) (OperationKind.ObjectCreation, Type: S<T>) (Syntax: '[a, b]')
+                  Arguments(0)
+                  Initializer:
+                    null
+            IInvocationOperation ( void S<T>.Add(T t)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'a')
+              Instance Receiver:
+                IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: S<T>, IsImplicit) (Syntax: '[a, b]')
+              Arguments(1):
+                  IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: t) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'a')
+                    IParameterReferenceOperation: a (OperationKind.ParameterReference, Type: T) (Syntax: 'a')
+                    InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                    OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+            IInvocationOperation ( void S<T>.Add(T t)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'b')
+              Instance Receiver:
+                IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: S<T>, IsImplicit) (Syntax: '[a, b]')
+              Arguments(1):
+                  IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: t) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'b')
+                    IParameterReferenceOperation: b (OperationKind.ParameterReference, Type: T) (Syntax: 'b')
+                    InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                    OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+        Next (Return) Block[B2]
+            IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: S<T>, IsImplicit) (Syntax: '[a, b]')
+              Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                (CollectionLiteral)
+              Operand:
+                IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: S<T>, IsImplicit) (Syntax: '[a, b]')
+            Leaving: {R1}
+}
+Block[B2] - Exit
+    Predecessors: [B1]
+    Statements (0)
+");
+        }
+
+        [Fact]
+        public void IOperation_TypeParameter()
+        {
+            string source = """
+                using System.Collections;
+                using System.Collections.Generic;
+                interface I<T> : IEnumerable<T>
+                {
+                    void Add(T t);
+                }
+                struct S<T> : I<T>
+                {
+                    public void Add(T t) { }
+                    IEnumerator<T> IEnumerable<T>.GetEnumerator() => throw null;
+                    IEnumerator IEnumerable.GetEnumerator() => throw null;
+                }
+                class Program
+                {
+                    static T Create<T, U>(U a, U b) where T : I<U>, new()
+                    {
+                        return /*<bind>*/[a, b]/*</bind>*/;
+                    }
+                }
+                """;
+
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics();
+
+            VerifyOperationTreeForTest<CollectionCreationExpressionSyntax>(comp,
+@"ITypeParameterObjectCreationOperation (OperationKind.TypeParameterObjectCreation, Type: T) (Syntax: '[a, b]')
+  Initializer:
+    IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: T, IsImplicit) (Syntax: '[a, b]')
+      Initializers(2):
+          IInvocationOperation (virtual void I<U>.Add(U t)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'a')
+            Instance Receiver:
+              IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: T, IsImplicit) (Syntax: '[a, b]')
+            Arguments(1):
+                IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: t) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'a')
+                  IParameterReferenceOperation: a (OperationKind.ParameterReference, Type: U) (Syntax: 'a')
+                  InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+          IInvocationOperation (virtual void I<U>.Add(U t)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'b')
+            Instance Receiver:
+              IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: T, IsImplicit) (Syntax: '[a, b]')
+            Arguments(1):
+                IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: t) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'b')
+                  IParameterReferenceOperation: b (OperationKind.ParameterReference, Type: U) (Syntax: 'b')
+                  InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+");
+
+            var tree = comp.SyntaxTrees[0];
+            var method = tree.GetRoot().DescendantNodes().OfType<MethodDeclarationSyntax>().Single(m => m.Identifier.Text == "Create");
+            VerifyFlowGraph(comp, method,
+@"Block[B0] - Entry
+    Statements (0)
+    Next (Regular) Block[B1]
+        Entering: {R1}
+.locals {R1}
+{
+    CaptureIds: [0]
+    Block[B1] - Block
+        Predecessors: [B0]
+        Statements (3)
+            IFlowCaptureOperation: 0 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: '[a, b]')
+              Value:
+                ITypeParameterObjectCreationOperation (OperationKind.TypeParameterObjectCreation, Type: T) (Syntax: '[a, b]')
+                  Initializer:
+                    null
+            IInvocationOperation (virtual void I<U>.Add(U t)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'a')
+              Instance Receiver:
+                IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: T, IsImplicit) (Syntax: '[a, b]')
+              Arguments(1):
+                  IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: t) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'a')
+                    IParameterReferenceOperation: a (OperationKind.ParameterReference, Type: U) (Syntax: 'a')
+                    InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                    OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+            IInvocationOperation (virtual void I<U>.Add(U t)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'b')
+              Instance Receiver:
+                IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: T, IsImplicit) (Syntax: '[a, b]')
+              Arguments(1):
+                  IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: t) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'b')
+                    IParameterReferenceOperation: b (OperationKind.ParameterReference, Type: U) (Syntax: 'b')
+                    InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                    OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+        Next (Return) Block[B2]
+            IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: T, IsImplicit) (Syntax: '[a, b]')
+              Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                (CollectionLiteral)
+              Operand:
+                IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: T, IsImplicit) (Syntax: '[a, b]')
+            Leaving: {R1}
+}
+Block[B2] - Exit
+    Predecessors: [B1]
+    Statements (0)
+");
+        }
+
+        [Fact]
+        public void IOperation_Nested()
+        {
+            string source = """
+                using System.Collections.Generic;
+                class Program
+                {
+                    static void Main()
+                    {
+                        List<List<int>> x = /*<bind>*/[[Get(1)]]/*</bind>*/;
+                    }
+                    static int Get(int value) => value;
+                }
+                """;
+
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics();
+
+            VerifyOperationTreeForTest<CollectionCreationExpressionSyntax>(comp,
+@"IObjectCreationOperation (Constructor: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>..ctor()) (OperationKind.ObjectCreation, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>) (Syntax: '[[Get(1)]]')
+  Arguments(0)
+  Initializer:
+    IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>, IsImplicit) (Syntax: '[[Get(1)]]')
+      Initializers(1):
+          IInvocationOperation ( void System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>.Add(System.Collections.Generic.List<System.Int32> item)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: '[Get(1)]')
+            Instance Receiver:
+              IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>, IsImplicit) (Syntax: '[[Get(1)]]')
+            Arguments(1):
+                IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: '[Get(1)]')
+                  IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Collections.Generic.List<System.Int32>, IsImplicit) (Syntax: '[Get(1)]')
+                    Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                    Operand:
+                      IObjectCreationOperation (Constructor: System.Collections.Generic.List<System.Int32>..ctor()) (OperationKind.ObjectCreation, Type: System.Collections.Generic.List<System.Int32>) (Syntax: '[Get(1)]')
+                        Arguments(0)
+                        Initializer:
+                          IObjectOrCollectionInitializerOperation (OperationKind.ObjectOrCollectionInitializer, Type: System.Collections.Generic.List<System.Int32>, IsImplicit) (Syntax: '[Get(1)]')
+                            Initializers(1):
+                                IInvocationOperation ( void System.Collections.Generic.List<System.Int32>.Add(System.Int32 item)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'Get(1)')
+                                  Instance Receiver:
+                                    IInstanceReferenceOperation (ReferenceKind: ImplicitReceiver) (OperationKind.InstanceReference, Type: System.Collections.Generic.List<System.Int32>, IsImplicit) (Syntax: '[Get(1)]')
+                                  Arguments(1):
+                                      IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'Get(1)')
+                                        IInvocationOperation (System.Int32 Program.Get(System.Int32 value)) (OperationKind.Invocation, Type: System.Int32) (Syntax: 'Get(1)')
+                                          Instance Receiver:
+                                            null
+                                          Arguments(1):
+                                              IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: value) (OperationKind.Argument, Type: null) (Syntax: '1')
+                                                ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1) (Syntax: '1')
+                                                InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                                                OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                                        InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                                        OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                  OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+");
+
+            var tree = comp.SyntaxTrees[0];
+            var method = tree.GetRoot().DescendantNodes().OfType<MethodDeclarationSyntax>().Single(m => m.Identifier.Text == "Main");
+            VerifyFlowGraph(comp, method,
+@"Block[B0] - Entry
+    Statements (0)
+    Next (Regular) Block[B1]
+        Entering: {R1}
+.locals {R1}
+{
+    Locals: [System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>> x]
+    CaptureIds: [0]
+    Block[B1] - Block
+        Predecessors: [B0]
+        Statements (1)
+            IFlowCaptureOperation: 0 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: '[[Get(1)]]')
+              Value:
+                IObjectCreationOperation (Constructor: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>..ctor()) (OperationKind.ObjectCreation, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>) (Syntax: '[[Get(1)]]')
+                  Arguments(0)
+                  Initializer:
+                    null
+        Next (Regular) Block[B2]
+            Entering: {R2}
+    .locals {R2}
+    {
+        CaptureIds: [1]
+        Block[B2] - Block
+            Predecessors: [B1]
+            Statements (3)
+                IFlowCaptureOperation: 1 (OperationKind.FlowCapture, Type: null, IsImplicit) (Syntax: '[Get(1)]')
+                  Value:
+                    IObjectCreationOperation (Constructor: System.Collections.Generic.List<System.Int32>..ctor()) (OperationKind.ObjectCreation, Type: System.Collections.Generic.List<System.Int32>) (Syntax: '[Get(1)]')
+                      Arguments(0)
+                      Initializer:
+                        null
+                IInvocationOperation ( void System.Collections.Generic.List<System.Int32>.Add(System.Int32 item)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: 'Get(1)')
+                  Instance Receiver:
+                    IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: System.Collections.Generic.List<System.Int32>, IsImplicit) (Syntax: '[Get(1)]')
+                  Arguments(1):
+                      IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: 'Get(1)')
+                        IInvocationOperation (System.Int32 Program.Get(System.Int32 value)) (OperationKind.Invocation, Type: System.Int32) (Syntax: 'Get(1)')
+                          Instance Receiver:
+                            null
+                          Arguments(1):
+                              IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: value) (OperationKind.Argument, Type: null) (Syntax: '1')
+                                ILiteralOperation (OperationKind.Literal, Type: System.Int32, Constant: 1) (Syntax: '1')
+                                InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                                OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                        InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                        OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                IInvocationOperation ( void System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>.Add(System.Collections.Generic.List<System.Int32> item)) (OperationKind.Invocation, Type: System.Void, IsImplicit) (Syntax: '[Get(1)]')
+                  Instance Receiver:
+                    IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>, IsImplicit) (Syntax: '[[Get(1)]]')
+                  Arguments(1):
+                      IArgumentOperation (ArgumentKind.Explicit, Matching Parameter: item) (OperationKind.Argument, Type: null, IsImplicit) (Syntax: '[Get(1)]')
+                        IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Collections.Generic.List<System.Int32>, IsImplicit) (Syntax: '[Get(1)]')
+                          Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                            (CollectionLiteral)
+                          Operand:
+                            IFlowCaptureReferenceOperation: 1 (OperationKind.FlowCaptureReference, Type: System.Collections.Generic.List<System.Int32>, IsImplicit) (Syntax: '[Get(1)]')
+                        InConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                        OutConversion: CommonConversion (Exists: True, IsIdentity: True, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+            Next (Regular) Block[B3]
+                Leaving: {R2}
+    }
+    Block[B3] - Block
+        Predecessors: [B2]
+        Statements (1)
+            ISimpleAssignmentOperation (OperationKind.SimpleAssignment, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>, IsImplicit) (Syntax: 'x = /*<bind>*/[[Get(1)]]')
+              Left:
+                ILocalReferenceOperation: x (IsDeclaration: True) (OperationKind.LocalReference, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>, IsImplicit) (Syntax: 'x = /*<bind>*/[[Get(1)]]')
+              Right:
+                IConversionOperation (TryCast: False, Unchecked) (OperationKind.Conversion, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>, IsImplicit) (Syntax: '[[Get(1)]]')
+                  Conversion: CommonConversion (Exists: True, IsIdentity: False, IsNumeric: False, IsReference: False, IsUserDefined: False) (MethodSymbol: null)
+                    (CollectionLiteral)
+                  Operand:
+                    IFlowCaptureReferenceOperation: 0 (OperationKind.FlowCaptureReference, Type: System.Collections.Generic.List<System.Collections.Generic.List<System.Int32>>, IsImplicit) (Syntax: '[[Get(1)]]')
+        Next (Regular) Block[B4]
+            Leaving: {R1}
+}
+Block[B4] - Exit
+    Predecessors: [B3]
+    Statements (0)
+");
+        }
+
+        [Fact]
+        public void Async()
+        {
+            string source = """
+                using System.Collections.Generic;
+                using System.Threading.Tasks;
+                class Program
+                {
+                    static async Task Main()
+                    {
+                        (await CreateArray()).Report();
+                        (await CreateList()).Report();
+                    }
+                    static async Task<int[]> CreateArray()
+                    {
+                        return [await F(1), await F(2)];
+                    }
+                    static async Task<List<int>> CreateList()
+                    {
+                        return [await F(3), await F(4)];
+                    }
+                    static async Task<int> F(int i)
+                    {
+                        Task.Yield();
+                        return i;
+                    }
+                }
+                """;
+            var verifier = CompileAndVerify(new[] { source, GetCollectionExtensions() }, expectedOutput: "[1, 2], [3, 4], ");
+            verifier.VerifyIL("Program.CreateArray", """
+                {
+                  // Code size       47 (0x2f)
+                  .maxstack  2
+                  .locals init (Program.<CreateArray>d__1 V_0)
+                  IL_0000:  ldloca.s   V_0
+                  IL_0002:  call       "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<int[]> System.Runtime.CompilerServices.AsyncTaskMethodBuilder<int[]>.Create()"
+                  IL_0007:  stfld      "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<int[]> Program.<CreateArray>d__1.<>t__builder"
+                  IL_000c:  ldloca.s   V_0
+                  IL_000e:  ldc.i4.m1
+                  IL_000f:  stfld      "int Program.<CreateArray>d__1.<>1__state"
+                  IL_0014:  ldloca.s   V_0
+                  IL_0016:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<int[]> Program.<CreateArray>d__1.<>t__builder"
+                  IL_001b:  ldloca.s   V_0
+                  IL_001d:  call       "void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<int[]>.Start<Program.<CreateArray>d__1>(ref Program.<CreateArray>d__1)"
+                  IL_0022:  ldloca.s   V_0
+                  IL_0024:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<int[]> Program.<CreateArray>d__1.<>t__builder"
+                  IL_0029:  call       "System.Threading.Tasks.Task<int[]> System.Runtime.CompilerServices.AsyncTaskMethodBuilder<int[]>.Task.get"
+                  IL_002e:  ret
+                }
+                """);
+            verifier.VerifyIL("Program.CreateList", """
+                {
+                  // Code size       47 (0x2f)
+                  .maxstack  2
+                  .locals init (Program.<CreateList>d__2 V_0)
+                  IL_0000:  ldloca.s   V_0
+                  IL_0002:  call       "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<System.Collections.Generic.List<int>> System.Runtime.CompilerServices.AsyncTaskMethodBuilder<System.Collections.Generic.List<int>>.Create()"
+                  IL_0007:  stfld      "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<System.Collections.Generic.List<int>> Program.<CreateList>d__2.<>t__builder"
+                  IL_000c:  ldloca.s   V_0
+                  IL_000e:  ldc.i4.m1
+                  IL_000f:  stfld      "int Program.<CreateList>d__2.<>1__state"
+                  IL_0014:  ldloca.s   V_0
+                  IL_0016:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<System.Collections.Generic.List<int>> Program.<CreateList>d__2.<>t__builder"
+                  IL_001b:  ldloca.s   V_0
+                  IL_001d:  call       "void System.Runtime.CompilerServices.AsyncTaskMethodBuilder<System.Collections.Generic.List<int>>.Start<Program.<CreateList>d__2>(ref Program.<CreateList>d__2)"
+                  IL_0022:  ldloca.s   V_0
+                  IL_0024:  ldflda     "System.Runtime.CompilerServices.AsyncTaskMethodBuilder<System.Collections.Generic.List<int>> Program.<CreateList>d__2.<>t__builder"
+                  IL_0029:  call       "System.Threading.Tasks.Task<System.Collections.Generic.List<int>> System.Runtime.CompilerServices.AsyncTaskMethodBuilder<System.Collections.Generic.List<int>>.Task.get"
+                  IL_002e:  ret
+                }
+                """);
+        }
+    }
+}
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/LocalFunctionTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/LocalFunctionTests.cs
index eed3a1c43dec2..554b07e7a1135 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/LocalFunctionTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/LocalFunctionTests.cs
@@ -9038,9 +9038,13 @@ public MyAttribute(string name1) { }
 }
 ";
             var comp = CreateCompilation(source);
-
-            // PROTOTYPE: Should report CS0103: The name 'parameter' does not exist in the current context
             comp.VerifyDiagnostics(
+                // (6,36): error CS0103: The name 'My' does not exist in the current context
+                //         System.Func<int, int> x = [My(nameof(parameter))] delegate { return 1; }
+                Diagnostic(ErrorCode.ERR_NameNotInContext, "My").WithArguments("My").WithLocation(6, 36),
+                // (6,46): error CS0103: The name 'parameter' does not exist in the current context
+                //         System.Func<int, int> x = [My(nameof(parameter))] delegate { return 1; }
+                Diagnostic(ErrorCode.ERR_NameNotInContext, "parameter").WithArguments("parameter").WithLocation(6, 46),
                 // (6,59): error CS1002: ; expected
                 //         System.Func<int, int> x = [My(nameof(parameter))] delegate { return 1; }
                 Diagnostic(ErrorCode.ERR_SemicolonExpected, "delegate").WithLocation(6, 59),
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionTests.cs
index e2282bb909cec..ffe61f2430118 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/OverloadResolutionTests.cs
@@ -7576,12 +7576,13 @@ static void Main(string[] args)
 ";
 
             var comp = CreateCompilation(source);
-
-            // PROTOTYPE: We should report diagnostic that this is an illegal assignment to an RVALUE.
             comp.VerifyDiagnostics(
                 // (2,1): hidden CS8019: Unnecessary using directive.
                 // using System.Collections.Generic;
-                Diagnostic(ErrorCode.HDN_UnusedUsingDirective, "using System.Collections.Generic;").WithLocation(2, 1));
+                Diagnostic(ErrorCode.HDN_UnusedUsingDirective, "using System.Collections.Generic;").WithLocation(2, 1),
+                // (8,28): error CS0131: The left-hand side of an assignment must be a variable, property or indexer
+                //         var d = new int[] {[1] = 3 };
+                Diagnostic(ErrorCode.ERR_AssgLvalueExpected, "[1]").WithLocation(8, 28));
         }
 
         [Fact]
diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/RecordStructTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/RecordStructTests.cs
index 4579831c95fa4..ac682bdba0861 100644
--- a/src/Compilers/CSharp/Test/Semantic/Semantics/RecordStructTests.cs
+++ b/src/Compilers/CSharp/Test/Semantic/Semantics/RecordStructTests.cs
@@ -9988,6 +9988,9 @@ public static void M()
 
             var expectedDiagnostics = new[]
             {
+                // (7,26): error CS0131: The left-hand side of an assignment must be a variable, property or indexer
+                //         var b = a with { [0] = 20 };
+                Diagnostic(ErrorCode.ERR_AssgLvalueExpected, "[0]").WithLocation(7, 26),
                 // (7,26): error CS0747: Invalid initializer member declarator
                 //         var b = a with { [0] = 20 };
                 Diagnostic(ErrorCode.ERR_InvalidInitializerElementInitializer, "[0] = 20").WithLocation(7, 26)
diff --git a/src/Compilers/Test/Core/Compilation/ControlFlowGraphVerifier.cs b/src/Compilers/Test/Core/Compilation/ControlFlowGraphVerifier.cs
index 334629d357d4f..e285004ada6e6 100644
--- a/src/Compilers/Test/Core/Compilation/ControlFlowGraphVerifier.cs
+++ b/src/Compilers/Test/Core/Compilation/ControlFlowGraphVerifier.cs
@@ -1143,6 +1143,12 @@ bool isLongLivedCaptureReferenceSyntax(SyntaxNode captureReferenceSyntax)
                                         return true;
                                     }
                                     break;
+                                case CSharp.SyntaxKind.CollectionCreationExpression:
+                                    if (((CSharp.Syntax.CollectionCreationExpressionSyntax)syntax).Elements.Any())
+                                    {
+                                        return true;
+                                    }
+                                    break;
                             }
 
                             if (syntax.Parent is CSharp.Syntax.WithExpressionSyntax withExpr
diff --git a/src/Compilers/VisualBasic/Portable/Symbols/MethodSymbol.vb b/src/Compilers/VisualBasic/Portable/Symbols/MethodSymbol.vb
index 4ac60fce32d45..0a3eb125ecaca 100644
--- a/src/Compilers/VisualBasic/Portable/Symbols/MethodSymbol.vb
+++ b/src/Compilers/VisualBasic/Portable/Symbols/MethodSymbol.vb
@@ -68,7 +68,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
 
         ''' <summary>
         ''' Returns the type arguments that have been substituted for the type parameters. 
-        ''' If nothing has been substituted for a give type parameters,
+        ''' If nothing has been substituted for a given type parameter,
         ''' then the type parameter itself is consider the type argument.
         ''' </summary>
         Public MustOverride ReadOnly Property TypeArguments As ImmutableArray(Of TypeSymbol)
diff --git a/src/Compilers/VisualBasic/Portable/Symbols/NamedTypeSymbol.vb b/src/Compilers/VisualBasic/Portable/Symbols/NamedTypeSymbol.vb
index 5679a6a081366..2756004b07df8 100644
--- a/src/Compilers/VisualBasic/Portable/Symbols/NamedTypeSymbol.vb
+++ b/src/Compilers/VisualBasic/Portable/Symbols/NamedTypeSymbol.vb
@@ -60,7 +60,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
 
         ''' <summary>
         ''' Returns the type arguments that have been substituted for the type parameters. 
-        ''' If nothing has been substituted for a give type parameters,
+        ''' If nothing has been substituted for a given type parameter,
         ''' then the type parameter itself is consider the type argument.
         ''' </summary>
         Friend MustOverride ReadOnly Property TypeArgumentsNoUseSiteDiagnostics As ImmutableArray(Of TypeSymbol)