[Ignore] Testing CI

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/ModifiedType.NativeAot.cs

@@ -1,20 +1,117 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Collections.Generic;
+using System.Reflection.Runtime.General;
+
+using Internal.Metadata.NativeFormat;
+
+using Debug = System.Diagnostics.Debug;
+
 namespace System.Reflection
 {
     internal partial class ModifiedType
     {
-        internal struct TypeSignature
+        internal readonly struct TypeSignature
+        {
+            internal readonly MetadataReader Reader;
+            internal readonly Handle Handle;
+            public TypeSignature(MetadataReader reader, Handle handle)
+                => (Reader, Handle) = (reader, handle);
+        }
+
+        internal Type GetTypeParameter(Type unmodifiedType, int index)
+        {
+            MetadataReader reader = _typeSignature.Reader;
+            Handle handle = _typeSignature.Handle;
+
+            while (handle.HandleType == HandleType.ModifiedType)
+                handle = reader.GetModifiedType(handle.ToModifiedTypeHandle(reader)).Type;
+
+            // TODO: should this be assert?
+            if (handle.HandleType == HandleType.TypeSpecification)
+                handle = reader.GetTypeSpecification(handle.ToTypeSpecificationHandle(reader)).Signature;
+
+            switch (handle.HandleType)
+            {
+                case HandleType.SZArraySignature:
+                    Debug.Assert(index == 0);
+                    return Create(unmodifiedType, new TypeSignature(reader, reader.GetSZArraySignature(handle.ToSZArraySignatureHandle(reader)).ElementType));
+                case HandleType.ArraySignature:
+                    Debug.Assert(index == 0);
+                    return Create(unmodifiedType, new TypeSignature(reader, reader.GetArraySignature(handle.ToArraySignatureHandle(reader)).ElementType));
+                case HandleType.PointerSignature:
+                    Debug.Assert(index == 0);
+                    return Create(unmodifiedType, new TypeSignature(reader, reader.GetPointerSignature(handle.ToPointerSignatureHandle(reader)).Type));
+                case HandleType.ByReferenceSignature:
+                    Debug.Assert(index == 0);
+                    return Create(unmodifiedType, new TypeSignature(reader, reader.GetByReferenceSignature(handle.ToByReferenceSignatureHandle(reader)).Type));
+                case HandleType.FunctionPointerSignature:
+                    {
+                        MethodSignature functionSig = reader.GetMethodSignature(
+                            reader.GetFunctionPointerSignature(handle.ToFunctionPointerSignatureHandle(reader)).Signature);
+                        if (index == 0)
+                            return Create(unmodifiedType, new TypeSignature(reader, functionSig.ReturnType));
+
+                        Debug.Assert(index <= functionSig.Parameters.Count);
+                        foreach (Handle paramHandle in functionSig.Parameters)
+                            if (--index == 0)
+                                return Create(unmodifiedType, new TypeSignature(reader, paramHandle));
+                    }
+                    break;
+                case HandleType.TypeInstantiationSignature:
+                    {
+                        TypeInstantiationSignature typeInst =
+                            reader.GetTypeInstantiationSignature(handle.ToTypeInstantiationSignatureHandle(reader));
+                        Debug.Assert(index < typeInst.GenericTypeArguments.Count);
+                        foreach (Handle paramHandle in typeInst.GenericTypeArguments)
+                            if (--index == 0)
+                                return Create(unmodifiedType, new TypeSignature(reader, paramHandle));
+                    }
+                    break;
+            }
+
+            Debug.Fail(handle.HandleType.ToString());
+            return null;
+        }
+
+        internal SignatureCallingConvention GetCallingConventionFromFunctionPointer()
         {
+            MetadataReader reader = _typeSignature.Reader;
+            Handle fnPtrTypeSigHandle = reader.GetTypeSpecification(
+                _typeSignature.Handle.ToTypeSpecificationHandle(reader)).Signature;
+            MethodSignatureHandle methodSigHandle = reader.GetFunctionPointerSignature(
+                fnPtrTypeSigHandle.ToFunctionPointerSignatureHandle(reader)).Signature;
+
+            Debug.Assert((int)Internal.Metadata.NativeFormat.SignatureCallingConvention.StdCall == (int)SignatureCallingConvention.StdCall);
+            Debug.Assert((int)Internal.Metadata.NativeFormat.SignatureCallingConvention.Unmanaged == (int)SignatureCallingConvention.Unmanaged);
+            return (SignatureCallingConvention)(reader.GetMethodSignature(methodSigHandle).CallingConvention
+                & Internal.Metadata.NativeFormat.SignatureCallingConvention.UnmanagedCallingConventionMask);
         }
 
-#pragma warning disable IDE0060
-        internal Type GetTypeParameter(Type unmodifiedType, int index) => throw new NotSupportedException();
+        private Type[] GetCustomModifiers(bool required)
+        {
+            ArrayBuilder<Type> builder = default;
+
+            MetadataReader reader = _typeSignature.Reader;
+            Handle handle = _typeSignature.Handle;
 
-        internal SignatureCallingConvention GetCallingConventionFromFunctionPointer() => throw new NotSupportedException();
+            while (handle.HandleType == HandleType.ModifiedType)
+            {
+                var modifiedType = reader.GetModifiedType(handle.ToModifiedTypeHandle(reader));
+
+                handle = modifiedType.Type;
+
+                if (modifiedType.IsOptional == required)
+                    continue;
+
+                builder.Add(modifiedType.ModifierType.Resolve(reader, new TypeContext(null, null)));
+            }
+
+            return builder.ToArray();
+        }
 
-        private Type[] GetCustomModifiers(bool required) => throw new NotSupportedException();
-#pragma warning restore IDE0060
+        public static ModifiedType Create(Type unmodifiedType, MetadataReader reader, Handle typeSignature)
+            => new ModifiedType(unmodifiedType, new TypeSignature(reader, typeSignature));
     }
 }

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Runtime/FieldInfos/NativeFormat/NativeFormatRuntimeFieldInfo.cs

@@ -162,6 +162,8 @@ protected sealed override RuntimeTypeInfo FieldRuntimeType
 
         protected sealed override int ExplicitLayoutFieldOffsetData => (int)(_field.Offset);
 
+        public sealed override Type GetModifiedFieldType() => ModifiedType.Create(FieldRuntimeType, _reader, FieldTypeHandle);
+
         private Handle FieldTypeHandle => _field.Signature.GetFieldSignature(_reader).Type;
 
         private readonly NativeFormatRuntimeNamedTypeInfo _definingTypeInfo;

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Runtime/General/QSignatureTypeHandle.cs

@@ -61,5 +61,10 @@ internal Type[] GetCustomModifiers(TypeContext typeContext, bool optional)
             return _handle.GetCustomModifiers((global::Internal.Metadata.NativeFormat.MetadataReader)Reader, typeContext, optional);
 #endif
         }
+
+        internal Type GetModifiedType(TypeContext typeContext)
+        {
+            return ModifiedType.Create(Resolve(typeContext), (global::Internal.Metadata.NativeFormat.MetadataReader)Reader, _handle);
+        }
     }
 }

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Runtime/ParameterInfos/RuntimeMethodParameterInfo.cs

@@ -36,6 +36,8 @@ public sealed override Type ParameterType
             }
         }
 
+        public sealed override Type GetModifiedParameterType() => QualifiedParameterTypeHandle.GetModifiedType(_typeContext);
+
         protected readonly QSignatureTypeHandle QualifiedParameterTypeHandle;
         private readonly TypeContext _typeContext;
         private volatile Type _lazyParameterType;

src/coreclr/nativeaot/System.Private.CoreLib/src/System/Reflection/Runtime/PropertyInfos/NativeFormat/NativeFormatRuntimePropertyInfo.cs

@@ -75,6 +75,12 @@ public sealed override IEnumerable<CustomAttributeData> CustomAttributes
             }
         }
 
+        public override Type GetModifiedPropertyType()
+        {
+            return ModifiedType.Create(PropertyType, _reader, _reader.GetPropertySignature(_property.Signature).Type);
+
+        }
+
         public sealed override bool HasSameMetadataDefinitionAs(MemberInfo other)
         {
             ArgumentNullException.ThrowIfNull(other);

src/coreclr/tools/Common/TypeSystem/Common/FieldDesc.cs

@@ -47,6 +47,8 @@ public abstract TypeDesc FieldType
         // Get the embedded signature data used to hold custom modifiers and such within a field signature
         public abstract EmbeddedSignatureData[] GetEmbeddedSignatureData();
 
+        public abstract bool HasEmbeddedSignatureData { get; }
+
         public abstract bool IsStatic
         {
             get;

src/coreclr/tools/Common/TypeSystem/Common/FieldForInstantiatedType.cs

@@ -54,6 +54,14 @@ public override EmbeddedSignatureData[] GetEmbeddedSignatureData()
             return _fieldDef.GetEmbeddedSignatureData();
         }
 
+        public override bool HasEmbeddedSignatureData
+        {
+            get
+            {
+                return _fieldDef.HasEmbeddedSignatureData;
+            }
+        }
+
         public override bool IsStatic
         {
             get

src/coreclr/tools/Common/TypeSystem/Ecma/EcmaField.cs

@@ -22,6 +22,9 @@ private static class FieldFlags
             public const int AttributeMetadataCache = 0x0100;
             public const int ThreadStatic           = 0x0200;
             public const int Intrinsic              = 0x0400;
+
+            // Computed when field type is computed
+            public const int HasEmbeddedSignatureData = 0x0800;
         };
 
         private EcmaType _type;
@@ -98,7 +101,11 @@ private TypeDesc InitializeFieldType()
             BlobReader signatureReader = metadataReader.GetBlobReader(metadataReader.GetFieldDefinition(_handle).Signature);
 
             EcmaSignatureParser parser = new EcmaSignatureParser(Module, signatureReader, NotFoundBehavior.Throw);
-            var fieldType = parser.ParseFieldSignature();
+            var fieldType = parser.ParseFieldSignature(out EmbeddedSignatureData[] data);
+
+            if (data != null)
+                _fieldFlags.AddFlags(FieldFlags.HasEmbeddedSignatureData);
+
             return (_fieldType = fieldType);
         }
 
@@ -112,6 +119,17 @@ public override TypeDesc FieldType
             }
         }
 
+        public override bool HasEmbeddedSignatureData
+        {
+            get
+            {
+                if (_fieldType == null)
+                    InitializeFieldType();
+
+                return _fieldFlags.HasFlags(FieldFlags.HasEmbeddedSignatureData);
+            }
+        }
+
         // This is extremely rarely needed. Don't cache it at all.
         public override EmbeddedSignatureData[] GetEmbeddedSignatureData()
         {

src/coreclr/tools/Common/TypeSystem/IL/Stubs/PInvokeLazyFixupField.cs

@@ -58,6 +58,8 @@ public override TypeDesc FieldType
 
         public override EmbeddedSignatureData[] GetEmbeddedSignatureData() => null;
 
+        public override bool HasEmbeddedSignatureData => false;
+
         public override bool HasRva
         {
             get

src/coreclr/tools/Common/TypeSystem/Interop/IL/InlineArrayType.cs

@@ -446,6 +446,8 @@ public override TypeDesc FieldType
             }
             public override EmbeddedSignatureData[] GetEmbeddedSignatureData() => null;
 
+            public override bool HasEmbeddedSignatureData => false;
+
             public override bool HasRva
             {
                 get

src/coreclr/tools/Common/TypeSystem/Interop/IL/NativeStructType.cs

@@ -372,6 +372,8 @@ public override TypeDesc FieldType
 
             public override EmbeddedSignatureData[] GetEmbeddedSignatureData() => null;
 
+            public override bool HasEmbeddedSignatureData => false;
+
             public override bool HasRva
             {
                 get

src/coreclr/tools/Common/TypeSystem/MetadataEmitter/TypeSystemMetadataEmitter.cs

@@ -269,11 +269,10 @@ private BlobHandle GetMethodSignatureBlobHandle(MethodSignature sig)
 
         private BlobHandle GetFieldSignatureBlobHandle(FieldDesc field)
         {
-            var embeddedSigData = field.GetEmbeddedSignatureData();
             EmbeddedSignatureDataEmitter signatureDataEmitter;
-            if (embeddedSigData != null && embeddedSigData.Length != 0)
+            if (field.HasEmbeddedSignatureData)
             {
-                signatureDataEmitter = new EmbeddedSignatureDataEmitter(embeddedSigData, this);
+                signatureDataEmitter = new EmbeddedSignatureDataEmitter(field.GetEmbeddedSignatureData(), this);
             }
             else
             {

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/DependencyAnalysis/FieldMetadataNode.cs

@@ -51,6 +51,13 @@ public override IEnumerable<DependencyListEntry> GetStaticDependencies(NodeFacto
                 GenericArgumentDataFlow.ProcessGenericArgumentDataFlow(ref dependencies, factory, new MessageOrigin(_field), ecmaField.FieldType, ecmaField.OwningType);
             }
 
+            if (_field.HasEmbeddedSignatureData)
+            {
+                foreach (var sigData in _field.GetEmbeddedSignatureData())
+                    if (sigData.type != null)
+                        TypeMetadataNode.GetMetadataDependencies(ref dependencies, factory, sigData.type, "Modifier in a field signature");
+            }
+
             return dependencies;
         }
         protected override string GetName(NodeFactory factory)

src/coreclr/tools/aot/ILCompiler.Compiler/Compiler/ExternSymbolMappedField.cs

@@ -27,6 +27,7 @@ public ExternSymbolMappedField(TypeDesc fieldType, string symbolName)
 
         public override TypeDesc FieldType => _fieldType;
         public override EmbeddedSignatureData[] GetEmbeddedSignatureData() => null;
+        public override bool HasEmbeddedSignatureData => false;
 
         public override bool IsStatic => true;
 

src/coreclr/tools/aot/ILCompiler.MetadataTransform/ILCompiler/Metadata/Transform.Field.cs

@@ -47,18 +47,21 @@ private Field HandleFieldDefinition(Cts.FieldDesc field)
         private void InitializeFieldDefinition(Cts.FieldDesc entity, Field record)
         {
             record.Name = HandleString(entity.Name);
-            record.Signature = new FieldSignature
-            {
-                Type = HandleType(entity.FieldType),
-                // TODO: CustomModifiers
-            };
             record.Flags = GetFieldAttributes(entity);
 
             var ecmaField = entity as Cts.Ecma.EcmaField;
             if (ecmaField != null)
             {
                 Ecma.MetadataReader reader = ecmaField.MetadataReader;
                 Ecma.FieldDefinition fieldDef = reader.GetFieldDefinition(ecmaField.Handle);
+
+                record.Signature = new FieldSignature
+                {
+                    Type = entity.HasEmbeddedSignatureData
+                        ? HandleFieldSignature(ecmaField.Module, fieldDef.Signature)
+                        : HandleType(entity.FieldType),
+                };
+
                 Ecma.ConstantHandle defaultValueHandle = fieldDef.GetDefaultValue();
                 if (!defaultValueHandle.IsNil)
                 {
@@ -77,6 +80,14 @@ private void InitializeFieldDefinition(Cts.FieldDesc entity, Field record)
             }
         }
 
+        private MetadataRecord HandleFieldSignature(Cts.Ecma.EcmaModule module, Ecma.BlobHandle sigBlob)
+        {
+            Ecma.BlobReader reader = module.MetadataReader.GetBlobReader(sigBlob);
+            Ecma.SignatureHeader header = reader.ReadSignatureHeader();
+            Debug.Assert(header.Kind == Ecma.SignatureKind.Field);
+            return HandleType(module, ref reader);
+        }
+
         private MemberReference HandleFieldReference(Cts.FieldDesc field)
         {
             return (MemberReference)_fields.GetOrCreate(field, _initFieldRef ??= InitializeFieldReference);