private RuntimeFatMethodParameterInfo(MethodBase member, MethodHandle methodHandle, int position, ParameterHandle parameterHandle, ReflectionDomain reflectionDomain, MetadataReader reader, Handle typeHandle, TypeContext typeContext)
: base(member, position, reflectionDomain, reader, typeHandle, typeContext)
{
_methodHandle = methodHandle;
_parameterHandle = parameterHandle;
_parameter = parameterHandle.GetParameter(reader);
}
internal Parameter(MetadataReader reader, ParameterHandle handle)
{
Debug.Assert(reader != null);
Debug.Assert(!handle.IsNil);
this.reader = reader;
this.rowId = handle.RowId;
}
//============================================================================================== // Default Value support. //============================================================================================== public abstract bool GetDefaultValueIfAny(MetadataReader reader, ParameterHandle parameterHandle, Type declaredType, IEnumerable<CustomAttributeData> customAttributes, out Object defaultValue);
public abstract IEnumerable<CustomAttributeData> GetPsuedoCustomAttributes(MetadataReader reader, ParameterHandle parameterHandle, MethodHandle declaringMethodHandle);
public PEParameterSymbolWithCustomModifiers(
PEModuleSymbol moduleSymbol,
Symbol containingSymbol,
int ordinal,
bool isByRef,
ushort countOfCustomModifiersPrecedingByRef,
TypeSymbol type,
ParameterHandle handle,
ImmutableArray<ModifierInfo<TypeSymbol>> customModifiers,
out bool isBad) :
base(moduleSymbol, containingSymbol, ordinal, isByRef, type, handle, customModifiers.Length, out isBad)
{
_customModifiers = CSharpCustomModifier.Convert(customModifiers);
_countOfCustomModifiersPrecedingByRef = countOfCustomModifiersPrecedingByRef;
Debug.Assert(_countOfCustomModifiersPrecedingByRef == 0 || isByRef);
Debug.Assert(_countOfCustomModifiersPrecedingByRef <= _customModifiers.Length);
}
private static FlowAnalysisAnnotations DecodeFlowAnalysisAttributes(PEModule module, ParameterHandle handle)
{
FlowAnalysisAnnotations annotations = FlowAnalysisAnnotations.None;
if (module.HasAttribute(handle, AttributeDescription.AllowNullAttribute))
{
annotations |= FlowAnalysisAnnotations.AllowNull;
}
if (module.HasAttribute(handle, AttributeDescription.DisallowNullAttribute))
{
annotations |= FlowAnalysisAnnotations.DisallowNull;
}
if (module.HasAttribute(handle, AttributeDescription.MaybeNullAttribute))
{
annotations |= FlowAnalysisAnnotations.MaybeNull;
}
else if (module.HasMaybeNullWhenOrNotNullWhenOrDoesNotReturnIfAttribute(handle, AttributeDescription.MaybeNullWhenAttribute, out bool when))
{
annotations |= (when ? FlowAnalysisAnnotations.MaybeNullWhenTrue : FlowAnalysisAnnotations.MaybeNullWhenFalse);
}
if (module.HasAttribute(handle, AttributeDescription.NotNullAttribute))
{
annotations |= FlowAnalysisAnnotations.NotNull;
}
else if (module.HasMaybeNullWhenOrNotNullWhenOrDoesNotReturnIfAttribute(handle, AttributeDescription.NotNullWhenAttribute, out bool when))
{
annotations |= (when ? FlowAnalysisAnnotations.NotNullWhenTrue : FlowAnalysisAnnotations.NotNullWhenFalse);
}
if (module.HasMaybeNullWhenOrNotNullWhenOrDoesNotReturnIfAttribute(handle, AttributeDescription.DoesNotReturnIfAttribute, out bool condition))
{
annotations |= (condition ? FlowAnalysisAnnotations.DoesNotReturnIfTrue : FlowAnalysisAnnotations.DoesNotReturnIfFalse);
}
return(annotations);
}
public static string ToString(this MetadataReader reader, ParameterHandle x) => reader.ToString(reader.GetParameter(x));
private PEParameterSymbol(
PEModuleSymbol moduleSymbol,
Symbol containingSymbol,
int ordinal,
bool isByRef,
TypeSymbol type,
ParameterHandle handle,
int countOfCustomModifiers,
out bool isBad)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingSymbol != null);
Debug.Assert(ordinal >= 0);
Debug.Assert((object)type != null);
isBad = false;
_moduleSymbol = moduleSymbol;
_containingSymbol = containingSymbol;
_ordinal = (ushort)ordinal;
_handle = handle;
RefKind refKind = RefKind.None;
if (handle.IsNil)
{
refKind = isByRef ? RefKind.Ref : RefKind.None;
type = TupleTypeSymbol.TransformToTupleIfCompatible(type); // temporary shallow unification
_type = type;
_lazyCustomAttributes = ImmutableArray<CSharpAttributeData>.Empty;
_lazyHiddenAttributes = ImmutableArray<CSharpAttributeData>.Empty;
_lazyDefaultValue = ConstantValue.NotAvailable;
_lazyIsParams = ThreeState.False;
}
else
{
try
{
moduleSymbol.Module.GetParamPropsOrThrow(handle, out _name, out _flags);
}
catch (BadImageFormatException)
{
isBad = true;
}
if (isByRef)
{
ParameterAttributes inOutFlags = _flags & (ParameterAttributes.Out | ParameterAttributes.In);
refKind = (inOutFlags == ParameterAttributes.Out) ? RefKind.Out : RefKind.Ref;
}
// CONSIDER: Can we make parameter type computation lazy?
type = DynamicTypeDecoder.TransformType(type, countOfCustomModifiers, handle, moduleSymbol, refKind);
_type = TupleTypeSymbol.TransformToTupleIfCompatible(type); // temporary shallow unification
}
bool hasNameInMetadata = !string.IsNullOrEmpty(_name);
if (!hasNameInMetadata)
{
// As was done historically, if the parameter doesn't have a name, we give it the name "value".
_name = "value";
}
_packedFlags = new PackedFlags(refKind, attributesAreComplete: handle.IsNil, hasNameInMetadata: hasNameInMetadata);
Debug.Assert(refKind == this.RefKind);
Debug.Assert(hasNameInMetadata == this.HasNameInMetadata);
}
public Mapping<ParameterHandle> MapParameter(ParameterHandle handle)
{
return _parameters.GetOrAdd(handle, MapParameterImpl);
}
internal StringHandle GetName(ParameterHandle handle)
{
int rowOffset = (handle.RowId - 1) * this.RowSize;
return StringHandle.FromOffset(this.Block.PeekHeapReference(rowOffset + _NameOffset, _IsStringHeapRefSizeSmall));
}
private ParameterHandle Import(ParameterHandle srcHandle) => _parameterCache.GetValueOrDefault(srcHandle);
internal StringHandle GetName(ParameterHandle handle)
{
int rowOffset = (int)(handle.RowId - 1) * this.RowSize;
return StringHandle.FromIndex(this.Block.PeekReference(rowOffset + this.NameOffset, this.IsStringHeapRefSizeSmall));
}
public void IsNil()
{
Assert.False(ModuleDefinitionHandle.FromRowId(1).IsNil);
Assert.False(AssemblyDefinitionHandle.FromRowId(1).IsNil);
Assert.False(InterfaceImplementationHandle.FromRowId(1).IsNil);
Assert.False(MethodDefinitionHandle.FromRowId(1).IsNil);
Assert.False(MethodSpecificationHandle.FromRowId(1).IsNil);
Assert.False(TypeDefinitionHandle.FromRowId(1).IsNil);
Assert.False(ExportedTypeHandle.FromRowId(1).IsNil);
Assert.False(TypeReferenceHandle.FromRowId(1).IsNil);
Assert.False(TypeSpecificationHandle.FromRowId(1).IsNil);
Assert.False(MemberReferenceHandle.FromRowId(1).IsNil);
Assert.False(FieldDefinitionHandle.FromRowId(1).IsNil);
Assert.False(EventDefinitionHandle.FromRowId(1).IsNil);
Assert.False(PropertyDefinitionHandle.FromRowId(1).IsNil);
Assert.False(StandaloneSignatureHandle.FromRowId(1).IsNil);
Assert.False(MemberReferenceHandle.FromRowId(1).IsNil);
Assert.False(FieldDefinitionHandle.FromRowId(1).IsNil);
Assert.False(EventDefinitionHandle.FromRowId(1).IsNil);
Assert.False(PropertyDefinitionHandle.FromRowId(1).IsNil);
Assert.False(ParameterHandle.FromRowId(1).IsNil);
Assert.False(GenericParameterHandle.FromRowId(1).IsNil);
Assert.False(GenericParameterConstraintHandle.FromRowId(1).IsNil);
Assert.False(ModuleReferenceHandle.FromRowId(1).IsNil);
Assert.False(CustomAttributeHandle.FromRowId(1).IsNil);
Assert.False(DeclarativeSecurityAttributeHandle.FromRowId(1).IsNil);
Assert.False(ManifestResourceHandle.FromRowId(1).IsNil);
Assert.False(ConstantHandle.FromRowId(1).IsNil);
Assert.False(ManifestResourceHandle.FromRowId(1).IsNil);
Assert.False(AssemblyFileHandle.FromRowId(1).IsNil);
Assert.False(MethodImplementationHandle.FromRowId(1).IsNil);
Assert.False(AssemblyReferenceHandle.FromRowId(1).IsNil);
Assert.False(((EntityHandle)ModuleDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)AssemblyDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)InterfaceImplementationHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MethodDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MethodSpecificationHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)TypeDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ExportedTypeHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)TypeReferenceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)TypeSpecificationHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MemberReferenceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)FieldDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)EventDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)PropertyDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)StandaloneSignatureHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MemberReferenceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)FieldDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)EventDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)PropertyDefinitionHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ParameterHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)GenericParameterHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)GenericParameterConstraintHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ModuleReferenceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)CustomAttributeHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)DeclarativeSecurityAttributeHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ManifestResourceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ConstantHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)ManifestResourceHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)AssemblyFileHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)MethodImplementationHandle.FromRowId(1)).IsNil);
Assert.False(((EntityHandle)AssemblyReferenceHandle.FromRowId(1)).IsNil);
Assert.False(StringHandle.FromOffset(1).IsNil);
Assert.False(BlobHandle.FromOffset(1).IsNil);
Assert.False(UserStringHandle.FromOffset(1).IsNil);
Assert.False(GuidHandle.FromIndex(1).IsNil);
Assert.False(DocumentNameBlobHandle.FromOffset(1).IsNil);
Assert.False(((Handle)StringHandle.FromOffset(1)).IsNil);
Assert.False(((Handle)BlobHandle.FromOffset(1)).IsNil);
Assert.False(((Handle)UserStringHandle.FromOffset(1)).IsNil);
Assert.False(((Handle)GuidHandle.FromIndex(1)).IsNil);
Assert.False(((BlobHandle)DocumentNameBlobHandle.FromOffset(1)).IsNil);
Assert.True(ModuleDefinitionHandle.FromRowId(0).IsNil);
Assert.True(AssemblyDefinitionHandle.FromRowId(0).IsNil);
Assert.True(InterfaceImplementationHandle.FromRowId(0).IsNil);
Assert.True(MethodDefinitionHandle.FromRowId(0).IsNil);
Assert.True(MethodSpecificationHandle.FromRowId(0).IsNil);
Assert.True(TypeDefinitionHandle.FromRowId(0).IsNil);
Assert.True(ExportedTypeHandle.FromRowId(0).IsNil);
Assert.True(TypeReferenceHandle.FromRowId(0).IsNil);
Assert.True(TypeSpecificationHandle.FromRowId(0).IsNil);
Assert.True(MemberReferenceHandle.FromRowId(0).IsNil);
Assert.True(FieldDefinitionHandle.FromRowId(0).IsNil);
Assert.True(EventDefinitionHandle.FromRowId(0).IsNil);
Assert.True(PropertyDefinitionHandle.FromRowId(0).IsNil);
Assert.True(StandaloneSignatureHandle.FromRowId(0).IsNil);
Assert.True(MemberReferenceHandle.FromRowId(0).IsNil);
Assert.True(FieldDefinitionHandle.FromRowId(0).IsNil);
Assert.True(EventDefinitionHandle.FromRowId(0).IsNil);
Assert.True(PropertyDefinitionHandle.FromRowId(0).IsNil);
Assert.True(ParameterHandle.FromRowId(0).IsNil);
Assert.True(GenericParameterHandle.FromRowId(0).IsNil);
Assert.True(GenericParameterConstraintHandle.FromRowId(0).IsNil);
Assert.True(ModuleReferenceHandle.FromRowId(0).IsNil);
Assert.True(CustomAttributeHandle.FromRowId(0).IsNil);
Assert.True(DeclarativeSecurityAttributeHandle.FromRowId(0).IsNil);
Assert.True(ManifestResourceHandle.FromRowId(0).IsNil);
Assert.True(ConstantHandle.FromRowId(0).IsNil);
Assert.True(ManifestResourceHandle.FromRowId(0).IsNil);
Assert.True(AssemblyFileHandle.FromRowId(0).IsNil);
Assert.True(MethodImplementationHandle.FromRowId(0).IsNil);
Assert.True(AssemblyReferenceHandle.FromRowId(0).IsNil);
Assert.True(((EntityHandle)ModuleDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)AssemblyDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)InterfaceImplementationHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MethodDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MethodSpecificationHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)TypeDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ExportedTypeHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)TypeReferenceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)TypeSpecificationHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MemberReferenceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)FieldDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)EventDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)PropertyDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)StandaloneSignatureHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MemberReferenceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)FieldDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)EventDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)PropertyDefinitionHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ParameterHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)GenericParameterHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)GenericParameterConstraintHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ModuleReferenceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)CustomAttributeHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)DeclarativeSecurityAttributeHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ManifestResourceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ConstantHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)ManifestResourceHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)AssemblyFileHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)MethodImplementationHandle.FromRowId(0)).IsNil);
Assert.True(((EntityHandle)AssemblyReferenceHandle.FromRowId(0)).IsNil);
// heaps:
Assert.True(StringHandle.FromOffset(0).IsNil);
Assert.True(BlobHandle.FromOffset(0).IsNil);
Assert.True(UserStringHandle.FromOffset(0).IsNil);
Assert.True(GuidHandle.FromIndex(0).IsNil);
Assert.True(DocumentNameBlobHandle.FromOffset(0).IsNil);
Assert.True(((Handle)StringHandle.FromOffset(0)).IsNil);
Assert.True(((Handle)BlobHandle.FromOffset(0)).IsNil);
Assert.True(((Handle)UserStringHandle.FromOffset(0)).IsNil);
Assert.True(((Handle)GuidHandle.FromIndex(0)).IsNil);
Assert.True(((BlobHandle)DocumentNameBlobHandle.FromOffset(0)).IsNil);
// virtual:
Assert.False(AssemblyReferenceHandle.FromVirtualIndex(0).IsNil);
Assert.False(StringHandle.FromVirtualIndex(0).IsNil);
Assert.False(BlobHandle.FromVirtualIndex(0, 0).IsNil);
Assert.False(((Handle)AssemblyReferenceHandle.FromVirtualIndex(0)).IsNil);
Assert.False(((Handle)StringHandle.FromVirtualIndex(0)).IsNil);
Assert.False(((Handle)BlobHandle.FromVirtualIndex(0, 0)).IsNil);
}
public abstract IEnumerable <CustomAttributeData> GetPsuedoCustomAttributes(MetadataReader reader, ParameterHandle parameterHandle, MethodHandle declaringMethodHandle);
//============================================================================================== // Default Value support. //============================================================================================== public abstract bool GetDefaultValueIfAny(MetadataReader reader, ParameterHandle parameterHandle, Type declaredType, IEnumerable <CustomAttributeData> customAttributes, out Object defaultValue);
internal ParameterAttributes GetFlags(ParameterHandle handle)
{
int rowOffset = (handle.RowId - 1) * this.RowSize;
return (ParameterAttributes)this.Block.PeekUInt16(rowOffset + _FlagsOffset);
}
public MethodDefinitionHandle AddMethodDefinition(
MethodAttributes attributes,
MethodImplAttributes implAttributes,
StringHandle name,
BlobHandle signature,
int bodyOffset,
ParameterHandle paramList)
{
_methodDefTable.Add(new MethodRow
{
Flags = (ushort)attributes,
ImplFlags = (ushort)implAttributes,
Name = name,
Signature = signature,
BodyOffset = bodyOffset,
ParamList = (uint)MetadataTokens.GetRowNumber(paramList)
});
return MetadataTokens.MethodDefinitionHandle(_methodDefTable.Count);
}
internal ushort GetSequence(ParameterHandle handle)
{
int rowOffset = (handle.RowId - 1) * this.RowSize;
return this.Block.PeekUInt16(rowOffset + _SequenceOffset);
}
/// <summary>
/// Construct a parameter symbol for a property loaded from metadata.
/// </summary>
/// <param name="moduleSymbol"></param>
/// <param name="containingSymbol"></param>
/// <param name="ordinal"></param>
/// <param name="handle">The property parameter doesn't have a name in metadata,
/// so this is the handle of a corresponding accessor parameter, if there is one,
/// or of the ParamInfo passed in, otherwise).</param>
/// <param name="isBad" />
/// <param name="parameter"></param>
internal PEParameterSymbol(
PEModuleSymbol moduleSymbol,
PEPropertySymbol containingSymbol,
int ordinal,
ParameterHandle handle,
MetadataDecoder.ParamInfo parameter,
out bool isBad)
: this(moduleSymbol, containingSymbol, ordinal, parameter.IsByRef, parameter.HasByRefBeforeCustomModifiers, parameter.Type, handle, parameter.CustomModifiers, out isBad)
{
}
private Mapping<ParameterHandle> MapParameterImpl(ParameterHandle handle)
{
throw new NotImplementedException();
}
private PEParameterSymbol(
PEModuleSymbol moduleSymbol,
Symbol containingSymbol,
int ordinal,
bool isByRef,
bool hasByRefBeforeCustomModifiers,
TypeSymbol type,
ParameterHandle handle,
ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers,
out bool isBad)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingSymbol != null);
Debug.Assert(ordinal >= 0);
Debug.Assert((object)type != null);
isBad = false;
_moduleSymbol = moduleSymbol;
_containingSymbol = containingSymbol;
_customModifiers = CSharpCustomModifier.Convert(customModifiers);
_ordinal = (ushort)ordinal;
_handle = handle;
RefKind refKind = RefKind.None;
if (handle.IsNil)
{
refKind = isByRef ? RefKind.Ref : RefKind.None;
_type = type;
_lazyCustomAttributes = ImmutableArray <CSharpAttributeData> .Empty;
_lazyHiddenAttributes = ImmutableArray <CSharpAttributeData> .Empty;
_lazyDefaultValue = ConstantValue.NotAvailable;
_lazyIsParams = ThreeState.False;
}
else
{
try
{
moduleSymbol.Module.GetParamPropsOrThrow(handle, out _name, out _flags);
}
catch (BadImageFormatException)
{
isBad = true;
}
if (isByRef)
{
ParameterAttributes inOutFlags = _flags & (ParameterAttributes.Out | ParameterAttributes.In);
refKind = (inOutFlags == ParameterAttributes.Out) ? RefKind.Out : RefKind.Ref;
}
// CONSIDER: Can we make parameter type computation lazy?
_type = DynamicTypeDecoder.TransformType(type, _customModifiers.Length, handle, moduleSymbol, refKind);
}
if (string.IsNullOrEmpty(_name))
{
// As was done historically, if the parameter doesn't have a name, we give it the name "value".
_name = "value";
}
_packedFlags = new PackedFlags(refKind, hasByRefBeforeCustomModifiers, attributesAreComplete: handle.IsNil);
Debug.Assert(refKind == this.RefKind);
Debug.Assert(hasByRefBeforeCustomModifiers == this.HasByRefBeforeCustomModifiers);
}
private PEParameterSymbol(
PEModuleSymbol moduleSymbol,
Symbol containingSymbol,
int ordinal,
bool isByRef,
bool hasByRefBeforeCustomModifiers,
TypeSymbol type,
ParameterHandle handle,
ImmutableArray<MetadataDecoder.ModifierInfo> customModifiers,
out bool isBad)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingSymbol != null);
Debug.Assert(ordinal >= 0);
Debug.Assert((object)type != null);
isBad = false;
this.moduleSymbol = moduleSymbol;
this.containingSymbol = containingSymbol;
this.customModifiers = CSharpCustomModifier.Convert(customModifiers);
this.ordinal = (ushort)ordinal;
this.handle = handle;
RefKind refKind = RefKind.None;
if (handle.IsNil)
{
refKind = isByRef ? RefKind.Ref : RefKind.None;
this.type = type;
this.lazyCustomAttributes = ImmutableArray<CSharpAttributeData>.Empty;
this.lazyHiddenAttributes = ImmutableArray<CSharpAttributeData>.Empty;
this.lazyWellKnownAttributeData = (int)WellKnownAttributeFlags.AllCompletedNoAttributes;
this.lazyDefaultValue = ConstantValue.NotAvailable;
this.lazyIsParams = ThreeState.False;
}
else
{
try
{
moduleSymbol.Module.GetParamPropsOrThrow(handle, out this.name, out this.flags);
}
catch (BadImageFormatException)
{
isBad = true;
}
if (isByRef)
{
ParameterAttributes inOutFlags = this.flags & (ParameterAttributes.Out | ParameterAttributes.In);
refKind = (inOutFlags == ParameterAttributes.Out) ? RefKind.Out : RefKind.Ref;
}
// CONSIDER: Can we make parameter type computation lazy?
this.type = DynamicTypeDecoder.TransformType(type, this.customModifiers.Length, handle, moduleSymbol, refKind);
}
if (string.IsNullOrEmpty(this.name))
{
// As was done historically, if the parameter doesn't have a name, we give it the name "value".
this.name = "value";
}
this.packed = Pack(refKind, hasByRefBeforeCustomModifiers);
Debug.Assert(refKind == this.RefKind);
Debug.Assert(hasByRefBeforeCustomModifiers == this.HasByRefBeforeCustomModifiers);
}
public sealed override IEnumerable<CustomAttributeData> GetPsuedoCustomAttributes(MetadataReader reader, ParameterHandle parameterHandle, MethodHandle declaringMethodHandle)
{
ParameterAttributes attributes = parameterHandle.GetParameter(reader).Flags;
if (0 != (attributes & ParameterAttributes.In))
yield return ReflectionCoreExecution.ExecutionDomain.GetCustomAttributeData(typeof(InAttribute), null, null);
if (0 != (attributes & ParameterAttributes.Out))
yield return ReflectionCoreExecution.ExecutionDomain.GetCustomAttributeData(typeof(OutAttribute), null, null);
if (0 != (attributes & ParameterAttributes.Optional))
yield return ReflectionCoreExecution.ExecutionDomain.GetCustomAttributeData(typeof(OptionalAttribute), null, null);
}
/// <summary>
/// Construct a parameter symbol for a property loaded from metadata.
/// </summary>
/// <param name="moduleSymbol"></param>
/// <param name="containingSymbol"></param>
/// <param name="ordinal"></param>
/// <param name="handle">The property parameter doesn't have a name in metadata,
/// so this is the handle of a corresponding accessor parameter, if there is one,
/// or of the ParamInfo passed in, otherwise).</param>
/// <param name="isBad" />
/// <param name="parameter"></param>
internal static PEParameterSymbol Create(
PEModuleSymbol moduleSymbol,
PEPropertySymbol containingSymbol,
int ordinal,
ParameterHandle handle,
ParamInfo<TypeSymbol> parameter,
out bool isBad)
{
return Create(moduleSymbol, containingSymbol, ordinal, parameter.IsByRef, parameter.CountOfCustomModifiersPrecedingByRef, parameter.Type, handle, parameter.CustomModifiers, out isBad);
}
//==============================================================================================
// Default Value support.
//==============================================================================================
public sealed override bool GetDefaultValueIfAny(MetadataReader reader, ParameterHandle parameterHandle, Type declaredType, IEnumerable<CustomAttributeData> customAttributes, out Object defaultValue)
{
Parameter parameter = parameterHandle.GetParameter(reader);
return DefaultValueParser.GetDefaultValueIfAny(DefaultValueParser.MemberType.Parameter, reader, parameter.DefaultValue, declaredType, customAttributes, out defaultValue);
}
private static PEParameterSymbol Create(
PEModuleSymbol moduleSymbol,
Symbol containingSymbol,
int ordinal,
bool isByRef,
ushort countOfCustomModifiersPrecedingByRef,
TypeSymbol type,
ParameterHandle handle,
ImmutableArray<ModifierInfo<TypeSymbol>> customModifiers,
out bool isBad)
{
if (customModifiers.IsDefaultOrEmpty)
{
return new PEParameterSymbol(moduleSymbol, containingSymbol, ordinal, isByRef, type, handle, 0, out isBad);
}
return new PEParameterSymbolWithCustomModifiers(moduleSymbol, containingSymbol, ordinal, isByRef, countOfCustomModifiersPrecedingByRef, type, handle, customModifiers, out isBad);
}
public PEParameterSymbolWithCustomModifiers(
PEModuleSymbol moduleSymbol,
Symbol containingSymbol,
int ordinal,
bool isByRef,
ImmutableArray<ModifierInfo<TypeSymbol>> refCustomModifiers,
TypeSymbol type,
ParameterHandle handle,
ImmutableArray<ModifierInfo<TypeSymbol>> customModifiers,
out bool isBad) :
base(moduleSymbol, containingSymbol, ordinal, isByRef, type, handle,
refCustomModifiers.NullToEmpty().Length + customModifiers.NullToEmpty().Length,
out isBad)
{
_customModifiers = CSharpCustomModifier.Convert(customModifiers);
_refCustomModifiers = CSharpCustomModifier.Convert(refCustomModifiers);
Debug.Assert(_refCustomModifiers.IsEmpty || isByRef);
}
public Parameter GetParameter(ParameterHandle handle)
{
return new Parameter(this, handle);
}
private PEParameterSymbol(
PEModuleSymbol moduleSymbol,
Symbol containingSymbol,
int ordinal,
bool isByRef,
TypeWithAnnotations typeWithAnnotations,
ParameterHandle handle,
Symbol nullableContext,
int countOfCustomModifiers,
out bool isBad)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingSymbol != null);
Debug.Assert(ordinal >= 0);
Debug.Assert(typeWithAnnotations.HasType);
isBad = false;
_moduleSymbol = moduleSymbol;
_containingSymbol = containingSymbol;
_ordinal = (ushort)ordinal;
_handle = handle;
RefKind refKind = RefKind.None;
if (handle.IsNil)
{
refKind = isByRef ? RefKind.Ref : RefKind.None;
byte?value = nullableContext.GetNullableContextValue();
if (value.HasValue)
{
typeWithAnnotations = NullableTypeDecoder.TransformType(typeWithAnnotations, value.GetValueOrDefault(), default);
}
_lazyCustomAttributes = ImmutableArray <CSharpAttributeData> .Empty;
_lazyHiddenAttributes = ImmutableArray <CSharpAttributeData> .Empty;
_lazyDefaultValue = ConstantValue.NotAvailable;
_lazyIsParams = ThreeState.False;
}
else
{
try
{
moduleSymbol.Module.GetParamPropsOrThrow(handle, out _name, out _flags);
}
catch (BadImageFormatException)
{
isBad = true;
}
if (isByRef)
{
ParameterAttributes inOutFlags = _flags & (ParameterAttributes.Out | ParameterAttributes.In);
if (inOutFlags == ParameterAttributes.Out)
{
refKind = RefKind.Out;
}
else if (moduleSymbol.Module.HasIsReadOnlyAttribute(handle))
{
refKind = RefKind.In;
}
else
{
refKind = RefKind.Ref;
}
}
var typeSymbol = DynamicTypeDecoder.TransformType(typeWithAnnotations.Type, countOfCustomModifiers, handle, moduleSymbol, refKind);
typeWithAnnotations = typeWithAnnotations.WithTypeAndModifiers(typeSymbol, typeWithAnnotations.CustomModifiers);
// Decode nullable before tuple types to avoid converting between
// NamedTypeSymbol and TupleTypeSymbol unnecessarily.
// The containing type is passed to NullableTypeDecoder.TransformType to determine access
// for property parameters because the property does not have explicit accessibility in metadata.
var accessSymbol = containingSymbol.Kind == SymbolKind.Property ? containingSymbol.ContainingSymbol : containingSymbol;
typeWithAnnotations = NullableTypeDecoder.TransformType(typeWithAnnotations, handle, moduleSymbol, accessSymbol: accessSymbol, nullableContext: nullableContext);
typeWithAnnotations = TupleTypeDecoder.DecodeTupleTypesIfApplicable(typeWithAnnotations, handle, moduleSymbol);
}
_typeWithAnnotations = typeWithAnnotations;
bool hasNameInMetadata = !string.IsNullOrEmpty(_name);
if (!hasNameInMetadata)
{
// As was done historically, if the parameter doesn't have a name, we give it the name "value".
_name = "value";
}
_packedFlags = new PackedFlags(refKind, attributesAreComplete: handle.IsNil, hasNameInMetadata: hasNameInMetadata);
Debug.Assert(refKind == this.RefKind);
Debug.Assert(hasNameInMetadata == this.HasNameInMetadata);
}
