Collection expressions: synthesize single-element list type for IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>

src/Compilers/CSharp/Portable/Compiler/MethodCompiler.cs

@@ -661,7 +661,7 @@ private void CompileSynthesizedMethods(PrivateImplementationDetails privateImplC
 
             var compilationState = new TypeCompilationState(null, _compilation, _moduleBeingBuiltOpt);
             var context = new EmitContext(_moduleBeingBuiltOpt, null, diagnostics.DiagnosticBag, metadataOnly: false, includePrivateMembers: true);
-            foreach (Cci.IMethodDefinition definition in privateImplClass.GetMethods(context).Concat(privateImplClass.GetTopLevelTypeMethods(context)))
+            foreach (Cci.IMethodDefinition definition in privateImplClass.GetMethods(context).Concat(privateImplClass.GetTopLevelAndNestedTypeMethods(context)))
             {
                 var method = (MethodSymbol)definition.GetInternalSymbol();
                 Debug.Assert(method.SynthesizesLoweredBoundBody);

src/Compilers/CSharp/Portable/Emitter/Model/PEModuleBuilder.cs

@@ -1916,19 +1916,19 @@ internal NamedTypeSymbol EnsureInlineArrayTypeExists(SyntaxNode syntaxNode, Synt
             return (NamedTypeSymbol)typeAdapter.GetInternalSymbol()!;
         }
 
-        internal NamedTypeSymbol EnsureReadOnlyListTypeExists(SyntaxNode syntaxNode, bool hasKnownLength, DiagnosticBag diagnostics)
+        internal NamedTypeSymbol EnsureReadOnlyListTypeExists(SyntaxNode syntaxNode, SynthesizedReadOnlyListKind kind, DiagnosticBag diagnostics)
         {
             Debug.Assert(syntaxNode is { });
             Debug.Assert(diagnostics is { });
 
-            string typeName = GeneratedNames.MakeSynthesizedReadOnlyListName(hasKnownLength, CurrentGenerationOrdinal);
+            string typeName = GeneratedNames.MakeSynthesizedReadOnlyListName(kind, CurrentGenerationOrdinal);
             var privateImplClass = GetPrivateImplClass(syntaxNode, diagnostics).PrivateImplementationDetails;
             var typeAdapter = privateImplClass.GetSynthesizedType(typeName);
             NamedTypeSymbol typeSymbol;
 
             if (typeAdapter is null)
             {
-                typeSymbol = SynthesizedReadOnlyListTypeSymbol.Create(SourceModule, typeName, hasKnownLength);
+                typeSymbol = SynthesizedReadOnlyListTypeSymbol.Create(SourceModule, typeName, kind);
                 privateImplClass.TryAddSynthesizedType(typeSymbol.GetCciAdapter());
                 typeAdapter = privateImplClass.GetSynthesizedType(typeName)!;
             }

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

@@ -312,32 +312,36 @@ SpecialType.System_Collections_Generic_IReadOnlyCollection_T or
                 int numberIncludingLastSpread;
                 bool useKnownLength = ShouldUseKnownLength(node, out numberIncludingLastSpread);
 
-                if (numberIncludingLastSpread == 0 && elements.Length == 0)
+                if (elements.Length == 0)
                 {
+                    Debug.Assert(numberIncludingLastSpread == 0);
                     // arrayOrList = Array.Empty<ElementType>();
                     arrayOrList = CreateEmptyArray(syntax, ArrayTypeSymbol.CreateSZArray(_compilation.Assembly, elementType));
                 }
                 else
                 {
                     var typeArgs = ImmutableArray.Create(elementType);
-                    var synthesizedType = _factory.ModuleBuilderOpt.EnsureReadOnlyListTypeExists(syntax, hasKnownLength: useKnownLength, _diagnostics.DiagnosticBag).Construct(typeArgs);
+                    var kind = useKnownLength
+                        ? numberIncludingLastSpread == 0 && elements.Length == 1 && SynthesizedReadOnlyListTypeSymbol.CanCreateSingleElement(_compilation)
+                            ? SynthesizedReadOnlyListKind.SingleElement
+                            : SynthesizedReadOnlyListKind.Array
+                        : SynthesizedReadOnlyListKind.List;
+                    var synthesizedType = _factory.ModuleBuilderOpt.EnsureReadOnlyListTypeExists(syntax, kind: kind, _diagnostics.DiagnosticBag).Construct(typeArgs);
                     if (synthesizedType.IsErrorType())
                     {
                         return BadExpression(node);
                     }
 
-                    BoundExpression fieldValue;
-                    if (useKnownLength)
+                    BoundExpression fieldValue = kind switch
                     {
+                        // fieldValue = e1;
+                        SynthesizedReadOnlyListKind.SingleElement => this.VisitExpression((BoundExpression)elements.Single()),
                         // fieldValue = new ElementType[] { e1, ..., eN };
-                        var arrayType = ArrayTypeSymbol.CreateSZArray(_compilation.Assembly, elementType);
-                        fieldValue = CreateAndPopulateArray(node, arrayType);
-                    }
-                    else
-                    {
+                        SynthesizedReadOnlyListKind.Array => CreateAndPopulateArray(node, ArrayTypeSymbol.CreateSZArray(_compilation.Assembly, elementType)),
                         // fieldValue = new List<ElementType> { e1, ..., eN };
-                        fieldValue = CreateAndPopulateList(node, elementType, elements);
-                    }
+                        SynthesizedReadOnlyListKind.List => CreateAndPopulateList(node, elementType, elements),
+                        var v => throw ExceptionUtilities.UnexpectedValue(v)
+                    };
 
                     // arrayOrList = new <>z__ReadOnlyList<ElementType>(fieldValue);
                     arrayOrList = new BoundObjectCreationExpression(syntax, synthesizedType.Constructors.Single(), fieldValue) { WasCompilerGenerated = true };

src/Compilers/CSharp/Portable/Symbols/Synthesized/GeneratedNames.cs

@@ -465,10 +465,16 @@ internal static string MakeSynthesizedInlineArrayName(int arrayLength, int gener
             return (generation > 0) ? name + GeneratedNameConstants.GenerationSeparator + generation : name;
         }
 
-        internal static string MakeSynthesizedReadOnlyListName(bool hasKnownLength, int generation)
+        internal static string MakeSynthesizedReadOnlyListName(SynthesizedReadOnlyListKind kind, int generation)
         {
             Debug.Assert((char)GeneratedNameKind.ReadOnlyListType == 'z');
-            string name = hasKnownLength ? "<>z__ReadOnlyArray" : "<>z__ReadOnlyList";
+            string name = kind switch
+            {
+                SynthesizedReadOnlyListKind.Array => "<>z__ReadOnlyArray",
+                SynthesizedReadOnlyListKind.List => "<>z__ReadOnlyList",
+                SynthesizedReadOnlyListKind.SingleElement => "<>z__ReadOnlySingleElementList",
+                var v => throw ExceptionUtilities.UnexpectedValue(v)
+            };
 
             // Synthesized list types need to have unique name across generations because they are not reused.
             return (generation > 0) ? name + CommonGeneratedNames.GenerationSeparator + generation : name;

src/Compilers/CSharp/Portable/Symbols/Synthesized/ReadOnlyListType/SynthesizedReadOnlyListConstructor.cs

@@ -9,10 +9,10 @@ namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
     internal sealed class SynthesizedReadOnlyListConstructor : SynthesizedInstanceConstructor
     {
-        internal SynthesizedReadOnlyListConstructor(SynthesizedReadOnlyListTypeSymbol containingType, TypeSymbol parameterType) : base(containingType)
+        internal SynthesizedReadOnlyListConstructor(SynthesizedReadOnlyListTypeSymbol containingType, TypeSymbol parameterType, string parameterName) : base(containingType)
         {
             Parameters = ImmutableArray.Create(
-                SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(parameterType), ordinal: 0, RefKind.None, "items"));
+                SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(parameterType), ordinal: 0, RefKind.None, parameterName));
         }
 
         public override ImmutableArray<ParameterSymbol> Parameters { get; }

src/Compilers/CSharp/Portable/Symbols/Synthesized/ReadOnlyListType/SynthesizedReadOnlyListEnumeratorConstructor.cs

@@ -0,0 +1,49 @@
+// 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.Linq;
+
+namespace Microsoft.CodeAnalysis.CSharp.Symbols
+{
+    internal sealed class SynthesizedReadOnlyListEnumeratorConstructor : SynthesizedInstanceConstructor
+    {
+        internal SynthesizedReadOnlyListEnumeratorConstructor(SynthesizedReadOnlyListEnumeratorTypeSymbol containingType, TypeSymbol parameterType) : base(containingType)
+        {
+            Parameters = ImmutableArray.Create(
+                SynthesizedParameterSymbol.Create(this, TypeWithAnnotations.Create(parameterType), ordinal: 0, RefKind.None, "item"));
+        }
+
+        public override ImmutableArray<ParameterSymbol> Parameters { get; }
+
+        internal override bool SynthesizesLoweredBoundBody => true;
+
+        internal override void GenerateMethodBody(TypeCompilationState compilationState, BindingDiagnosticBag diagnostics)
+        {
+            SyntheticBoundNodeFactory f = new SyntheticBoundNodeFactory(this, this.GetNonNullSyntaxNode(), compilationState, diagnostics);
+            f.CurrentFunction = this;
+
+            try
+            {
+                var baseConstructor = ContainingType.BaseTypeNoUseSiteDiagnostics.InstanceConstructors.Single();
+                var field = ContainingType.GetFieldsToEmit().First();
+                var parameter = Parameters.Single();
+
+                var block = f.Block(
+                    // object..ctor();
+                    f.ExpressionStatement(f.Call(f.This(), baseConstructor)),
+                    // _item = item;
+                    f.Assignment(f.Field(f.This(), field), f.Parameter(parameter)),
+                    // return;
+                    f.Return());
+                f.CloseMethod(block);
+            }
+            catch (SyntheticBoundNodeFactory.MissingPredefinedMember ex)
+            {
+                diagnostics.Add(ex.Diagnostic);
+                f.CloseMethod(f.ThrowNull());
+            }
+        }
+    }
+}