Implement compiler support for System.Runtime.InteropServices.ExtendedLayoutAttribute

docs/features/ExtendedLayoutAttribute.md

@@ -0,0 +1,16 @@
+System.Runtime.InteropServices.ExtendedLayoutAttribute Compiler Support
+=======================================================================
+
+The .NET runtime team is introducing a new attribute, `System.Runtime.InteropServices.ExtendedLayoutAttribute`, which will allow the runtime team to provide additional layout options for types, primarily for interop scenarios.
+To provide the user experience requested by the runtime team, the C# and VB compilers will have the following support for this attribute:
+
+- If a type has the `ExtendedLayoutAttribute` applied, the compiler will emit the `TypeAttributes.ExtendedLayout` value in the type's `TypeAttributes` flags.
+- If a type has the `ExtendedLayoutAttribute` applied, the compiler will not allow the `StructLayoutAttribute` to be applied to the type.
+- (C# compiler only) If a type has the `ExtendedLayoutAttribute` applied, the compiler will not allow the `InlineArrayAttribute` to be applied to the type.
+- Within the Roslyn compiler, the `ITypeSymbol` for a type with the `ExtendedLayoutAttribute` applied will have the following behavior:
+  - The `Layout` property will return a `TypeLayout` instance with the `LayoutKind` set to `Extended` (`1`), `Size` set to `0` and `Pack` set to `0`.
+- A type that is embedded in an assembly (using the `NoPia` technology) will have the `ExtendedLayoutAttribute` preserved on the embedded type.
+
+The Roslyn compiler will not have knowledge of the specific options available on the `ExtendedLayoutAttribute`, as these options will be defined by the runtime team and may expand over time. The compiler will not attempt to detect invalid field types for specific layout options. The runtime team may add analyzers in the future to handle these scenarios.
+
+The compiler will only recognize the presence of the attribute and its implications for the type symbol's `LayoutKind` and the emitted attribute.

src/Compilers/CSharp/Portable/CSharpResources.resx

@@ -8099,6 +8099,12 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ
   <data name="ERR_PPShebangInProjectBasedProgram" xml:space="preserve">
     <value>'#!' directives can be only used in scripts or file-based programs</value>
   </data>
+  <data name="ERR_StructLayoutAndExtendedLayout" xml:space="preserve">
+    <value>Use of 'StructLayoutAttribute' and 'ExtendedLayoutAttribute' on the same type is not allowed.</value>
+  </data>`
+  <data name="ERR_RuntimeDoesNotSupportExtendedLayoutTypes" xml:space="preserve">
+    <value>The target runtime does not support extended layout types.</value>
+  </data>
   <data name="ERR_MisplacedExtension" xml:space="preserve">
     <value>An extension member syntax is disallowed in nested position within an extension member syntax</value>
   </data>

src/Compilers/CSharp/Portable/Emitter/NoPia/EmbeddedTypesManager.cs

@@ -39,6 +39,7 @@ internal sealed class EmbeddedTypesManager :
         private readonly ConcurrentDictionary<Symbol, bool> _reportedSymbolsMap = new ConcurrentDictionary<Symbol, bool>(ReferenceEqualityComparer.Instance);
         private NamedTypeSymbol _lazySystemStringType = ErrorTypeSymbol.UnknownResultType;
         private readonly MethodSymbol[] _lazyWellKnownTypeMethods;
+        private readonly MethodSymbol[] _lazySpecialTypeMethods;
 
         public EmbeddedTypesManager(PEModuleBuilder moduleBeingBuilt) :
             base(moduleBeingBuilt)
@@ -49,6 +50,13 @@ public EmbeddedTypesManager(PEModuleBuilder moduleBeingBuilt) :
             {
                 _lazyWellKnownTypeMethods[i] = ErrorMethodSymbol.UnknownMethod;
             }
+
+            _lazySpecialTypeMethods = new MethodSymbol[(int)SpecialMember.Count];
+
+            for (int i = 0; i < _lazySpecialTypeMethods.Length; i++)
+            {
+                _lazySpecialTypeMethods[i] = ErrorMethodSymbol.UnknownMethod;
+            }
         }
 
         public NamedTypeSymbol GetSystemStringType(SyntaxNode syntaxNodeOpt, DiagnosticBag diagnostics)
@@ -115,6 +123,38 @@ private MethodSymbol LazyGetWellKnownTypeMethod(ref MethodSymbol lazyMethod, Wel
             return lazyMethod;
         }
 
+        public MethodSymbol GetSpecialMethod(SpecialMember method, SyntaxNode syntaxNodeOpt, DiagnosticBag diagnostics)
+        {
+            return LazyGetSpecialTypeMethod(ref _lazySpecialTypeMethods[(int)method],
+                                              method,
+                                              syntaxNodeOpt,
+                                              diagnostics);
+        }
+
+        private MethodSymbol LazyGetSpecialTypeMethod(ref MethodSymbol lazyMethod, SpecialMember member, SyntaxNode syntaxNodeOpt, DiagnosticBag diagnostics)
+        {
+            if ((object)lazyMethod == (object)ErrorMethodSymbol.UnknownMethod)
+            {
+                BindingDiagnosticBag bindingDiagnosticBag = BindingDiagnosticBag.GetInstance();
+                var symbol = (MethodSymbol)Binder.GetSpecialTypeMember(ModuleBeingBuilt.Compilation,
+                                                                         member,
+                                                                         bindingDiagnosticBag,
+                                                                         syntaxNodeOpt);
+
+                if (bindingDiagnosticBag.HasAnyErrors())
+                {
+                    symbol = null;
+                }
+
+                if (Interlocked.CompareExchange(ref lazyMethod, symbol, ErrorMethodSymbol.UnknownMethod) == ErrorMethodSymbol.UnknownMethod)
+                {
+                    diagnostics.AddRange(bindingDiagnosticBag.DiagnosticBag);
+                }
+            }
+
+            return lazyMethod;
+        }
+
         internal override int GetTargetAttributeSignatureIndex(CSharpAttributeData attrData, AttributeDescription description)
         {
             return attrData.GetTargetAttributeSignatureIndex(description);
@@ -152,6 +192,17 @@ internal override CSharpAttributeData CreateSynthesizedAttribute(WellKnownMember
             }
         }
 
+        internal override CSharpAttributeData CreateSynthesizedAttribute(SpecialMember constructor, ImmutableArray<TypedConstant> constructorArguments, ImmutableArray<KeyValuePair<string, TypedConstant>> namedArguments, SyntaxNode syntaxNodeOpt, DiagnosticBag diagnostics)
+        {
+            var ctor = GetSpecialMethod(constructor, syntaxNodeOpt, diagnostics);
+            if ((object)ctor == null)
+            {
+                return null;
+            }
+
+            return SynthesizedAttributeData.Create(ModuleBeingBuilt.Compilation, ctor, constructorArguments, namedArguments);
+        }
+
         internal override bool TryGetAttributeArguments(CSharpAttributeData attrData, out ImmutableArray<TypedConstant> constructorArguments, out ImmutableArray<KeyValuePair<string, TypedConstant>> namedArguments, SyntaxNode syntaxNodeOpt, DiagnosticBag diagnostics)
         {
             bool result = !attrData.HasErrors;

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

@@ -2447,6 +2447,9 @@ internal enum ErrorCode
         ERR_EncUpdateRequiresEmittingExplicitInterfaceImplementationNotSupportedByTheRuntime = 9346,
         ERR_ExtensionParameterInStaticContext = 9347,
 
+        ERR_StructLayoutAndExtendedLayout = 9348,
+        ERR_RuntimeDoesNotSupportExtendedLayoutTypes = 9349,
+
         // Note: you will need to do the following after adding errors:
         //  1) Update ErrorFacts.IsBuildOnlyDiagnostic (src/Compilers/CSharp/Portable/Errors/ErrorFacts.cs)
         //  2) Add message to CSharpResources.resx

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

@@ -2554,6 +2554,8 @@ or ErrorCode.ERR_UnexpectedArgumentListInBaseTypeWithoutParameterList
                 or ErrorCode.ERR_EqualityOperatorInPatternNotSupported
                 or ErrorCode.ERR_InequalityOperatorInPatternNotSupported
                 or ErrorCode.ERR_DesignatorBeforePropertyPattern
+                or ErrorCode.ERR_StructLayoutAndExtendedLayout
+                or ErrorCode.ERR_RuntimeDoesNotSupportExtendedLayoutTypes
                     => false,
             };
 #pragma warning restore CS8524 // The switch expression does not handle some values of its input type (it is not exhaustive) involving an unnamed enum value.

src/Compilers/CSharp/Portable/Symbols/AssemblySymbol.cs

@@ -486,6 +486,18 @@ internal bool RuntimeSupportsInlineArrayTypes
             }
         }
 
+        /// <summary>
+        /// Figure out if the target runtime supports extended layout types.
+        /// </summary>
+        internal bool RuntimeSupportsExtendedLayout
+        {
+            // Keep in sync with VB's AssemblySymbol.RuntimeSupportsExtendedLayout
+            get
+            {
+                return GetSpecialTypeMember(SpecialMember.System_Runtime_InteropServices_ExtendedLayoutAttribute__ctor) is object;
+            }
+        }
+
         /// <summary>
         /// Figure out if the target runtime supports inline array types.
         /// </summary>

src/Compilers/CSharp/Portable/Symbols/Source/SourceAssemblySymbol.cs

@@ -2724,7 +2724,7 @@ internal ImmutableArray<Diagnostic> GetUnusedFieldWarnings(CancellationToken can
                         handledUnreadFields.Add(field);
                     }
 
-                    if (containingType.HasStructLayoutAttribute || containingType.HasInlineArrayAttribute(out _))
+                    if (containingType.HasStructLayoutAttribute || containingType.HasExtendedLayoutAttribute || containingType.HasInlineArrayAttribute(out _))
                     {
                         continue;
                     }

src/Compilers/CSharp/Portable/Symbols/Source/SourceMemberContainerSymbol.cs

@@ -3035,7 +3035,7 @@ private static bool InfiniteFlatteningGraph(SourceMemberContainerTypeSymbol top,
 
         private void CheckSequentialOnPartialType(BindingDiagnosticBag diagnostics)
         {
-            if (!IsPartial || this.Layout.Kind != LayoutKind.Sequential)
+            if (!IsPartial || (this.Layout.Kind != LayoutKind.Sequential && this.Layout.Kind != LayoutKind.Extended))
             {
                 return;
             }

src/Compilers/CSharp/Portable/Symbols/Source/SourceNamedTypeSymbol.cs

@@ -13,6 +13,7 @@
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Threading;
+using System.Xml.Linq;
 using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -1227,6 +1228,10 @@ protected sealed override void DecodeWellKnownAttributeImpl(ref DecodeWellKnownA
             {
                 arguments.GetOrCreateData<TypeWellKnownAttributeData>().HasCompilerLoweringPreserveAttribute = true;
             }
+            else if (attribute.IsTargetAttribute(AttributeDescription.ExtendedLayoutAttribute))
+            {
+                arguments.GetOrCreateData<TypeWellKnownAttributeData>().HasExtendedLayoutAttribute = true;
+            }
             else
             {
                 var compilation = this.DeclaringCompilation;
@@ -1509,7 +1514,13 @@ internal sealed override TypeLayout Layout
             get
             {
                 var data = GetDecodedWellKnownAttributeData();
-                if (data != null && data.HasStructLayoutAttribute)
+
+                if (data is { HasExtendedLayoutAttribute: true })
+                {
+                    return new TypeLayout(LayoutKind.Extended, 0, alignment: 0);
+                }
+
+                if (data is { HasStructLayoutAttribute: true })
                 {
                     return data.Layout;
                 }
@@ -1521,6 +1532,7 @@ internal sealed override TypeLayout Layout
                     // 
                     // Dev11 compiler sets the value to 1 for structs with no instance fields and no size specified.
                     // It does not change the size value if it was explicitly specified to be 0, nor does it report an error.
+
                     return new TypeLayout(LayoutKind.Sequential, this.HasInstanceFields() ? 0 : 1, alignment: 0);
                 }
 
@@ -1546,6 +1558,15 @@ internal override CharSet MarshallingCharSet
             }
         }
 
+        internal bool HasExtendedLayoutAttribute
+        {
+            get
+            {
+                var data = GetDecodedWellKnownAttributeData();
+                return data is { HasExtendedLayoutAttribute: true };
+            }
+        }
+
         internal sealed override bool HasDeclarativeSecurity
         {
             get
@@ -1885,9 +1906,15 @@ protected override void AfterMembersCompletedChecks(BindingDiagnosticBag diagnos
                 Binder.GetWellKnownTypeMember(DeclaringCompilation, WellKnownMember.System_Reflection_DefaultMemberAttribute__ctor, diagnostics, indexerSymbol.TryGetFirstLocation() ?? GetFirstLocation());
             }
 
+            if (HasStructLayoutAttribute && HasExtendedLayoutAttribute)
+            {
+                // Use of 'StructLayoutAttribute' and 'ExtendedLayoutAttribute' on the same type is not allowed.
+                diagnostics.Add(ErrorCode.ERR_StructLayoutAndExtendedLayout, GetFirstLocation());
+            }
+
             if (TypeKind == TypeKind.Struct && !IsRecordStruct && HasInlineArrayAttribute(out _))
             {
-                if (Layout.Kind == LayoutKind.Explicit)
+                if (Layout.Kind is not (LayoutKind.Sequential or LayoutKind.Auto))
                 {
                     diagnostics.Add(ErrorCode.ERR_InvalidInlineArrayLayout, GetFirstLocation());
                 }
@@ -1971,6 +1998,14 @@ protected override void AfterMembersCompletedChecks(BindingDiagnosticBag diagnos
                 }
             }
 
+            if (TypeKind == TypeKind.Struct && HasExtendedLayoutAttribute)
+            {
+                if (!ContainingAssembly.RuntimeSupportsExtendedLayout)
+                {
+                    diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportExtendedLayoutTypes, GetFirstLocation());
+                }
+            }
+
             if (this.IsMicrosoftCodeAnalysisEmbeddedAttribute())
             {
                 // This is a user-defined implementation of the special attribute Microsoft.CodeAnalysis.EmbeddedAttribute. It needs to follow specific rules: