private void EnsureSignatureIsLoaded()
{
if ((object)lazyType == null)
{
var moduleSymbol = this.containingType.ContainingPEModule;
bool isVolatile;
ImmutableArray <MetadataDecoder.ModifierInfo> customModifiers;
TypeSymbol type = (new MetadataDecoder(moduleSymbol, this.containingType)).DecodeFieldSignature(this.handle, out isVolatile, out customModifiers);
ImmutableArray <CustomModifier> customModifiersArray = CSharpCustomModifier.Convert(customModifiers);
type = DynamicTypeDecoder.TransformType(type, customModifiersArray.Length, this.handle, moduleSymbol);
this.lazyIsVolatile = isVolatile;
TypeSymbol fixedElementType;
int fixedSize;
if (customModifiersArray.IsEmpty && IsFixedBuffer(out fixedSize, out fixedElementType))
{
this.lazyFixedSize = fixedSize;
this.lazyFixedImplementationType = type as NamedTypeSymbol;
type = new PointerTypeSymbol(fixedElementType);
}
ImmutableInterlocked.InterlockedCompareExchange(ref lazyCustomModifiers, customModifiersArray, default(ImmutableArray <CustomModifier>));
Interlocked.CompareExchange(ref lazyType, type, null);
}
}
private void EnsureSignatureIsLoaded()
{
if (_lazyType == null)
{
var moduleSymbol = _containingType.ContainingPEModule;
FieldInfo <TypeSymbol> fieldInfo = new MetadataDecoder(moduleSymbol, _containingType).DecodeFieldSignature(_handle);
TypeSymbol typeSymbol = fieldInfo.Type;
ImmutableArray <CustomModifier> customModifiersArray = CSharpCustomModifier.Convert(fieldInfo.CustomModifiers);
typeSymbol = DynamicTypeDecoder.TransformType(typeSymbol, customModifiersArray.Length, _handle, moduleSymbol);
typeSymbol = NativeIntegerTypeDecoder.TransformType(typeSymbol, _handle, moduleSymbol, _containingType);
// We start without annotations
var type = TypeWithAnnotations.Create(typeSymbol, customModifiers: customModifiersArray);
// Decode nullable before tuple types to avoid converting between
// NamedTypeSymbol and TupleTypeSymbol unnecessarily.
type = NullableTypeDecoder.TransformType(type, _handle, moduleSymbol, accessSymbol: this, nullableContext: _containingType);
type = TupleTypeDecoder.DecodeTupleTypesIfApplicable(type, _handle, moduleSymbol);
RefKind refKind = fieldInfo.IsByRef ?
moduleSymbol.Module.HasIsReadOnlyAttribute(_handle) ? RefKind.RefReadOnly : RefKind.Ref :
RefKind.None;
_packedFlags.SetRefKind(refKind);
_packedFlags.SetIsVolatile(customModifiersArray.Any(static m => !m.IsOptional && ((CSharpCustomModifier)m).ModifierSymbol.SpecialType == SpecialType.System_Runtime_CompilerServices_IsVolatile));
private void EnsureSignatureIsLoaded()
{
if (_lazyType.IsNull)
{
var moduleSymbol = _containingType.ContainingPEModule;
ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers;
TypeSymbol typeSymbol = (new MetadataDecoder(moduleSymbol, _containingType)).DecodeFieldSignature(_handle, out customModifiers);
ImmutableArray <CustomModifier> customModifiersArray = CSharpCustomModifier.Convert(customModifiers);
// We start without annotations
var type = TypeSymbolWithAnnotations.Create(typeSymbol, customModifiers: customModifiersArray);
// Decode nullable before tuple types to avoid converting between
// NamedTypeSymbol and TupleTypeSymbol unnecessarily.
type = NullableTypeDecoder.TransformType(type, _handle, moduleSymbol);
type = TupleTypeDecoder.DecodeTupleTypesIfApplicable(type, _handle, moduleSymbol);
TypeSymbol fixedElementType;
int fixedSize;
if (customModifiersArray.IsEmpty && IsFixedBuffer(out fixedSize, out fixedElementType))
{
_lazyFixedSize = fixedSize;
_lazyFixedImplementationType = type.TypeSymbol as NamedTypeSymbol;
type = TypeSymbolWithAnnotations.Create(new PointerTypeSymbol(TypeSymbolWithAnnotations.Create(fixedElementType)));
}
_lazyType.InterlockedInitialize(type);
}
}
private void EnsureSignatureIsLoaded()
{
if (_lazyType == null)
{
var moduleSymbol = _containingType.ContainingPEModule;
bool isVolatile;
ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers;
TypeSymbol typeSymbol = (new MetadataDecoder(moduleSymbol, _containingType)).DecodeFieldSignature(_handle, out isVolatile, out customModifiers);
ImmutableArray <CustomModifier> customModifiersArray = CSharpCustomModifier.Convert(customModifiers);
typeSymbol = DynamicTypeDecoder.TransformType(typeSymbol, customModifiersArray.Length, _handle, moduleSymbol);
// We start without annotations
var type = TypeWithAnnotations.Create(typeSymbol, customModifiers: customModifiersArray);
// Decode nullable before tuple types to avoid converting between
// NamedTypeSymbol and TupleTypeSymbol unnecessarily.
type = NullableTypeDecoder.TransformType(type, _handle, moduleSymbol, accessSymbol: this, nullableContext: _containingType);
type = TupleTypeDecoder.DecodeTupleTypesIfApplicable(type, _handle, moduleSymbol);
_lazyIsVolatile = isVolatile;
TypeSymbol fixedElementType;
int fixedSize;
if (customModifiersArray.IsEmpty && IsFixedBuffer(out fixedSize, out fixedElementType))
{
_lazyFixedSize = fixedSize;
_lazyFixedImplementationType = type.Type as NamedTypeSymbol;
type = TypeWithAnnotations.Create(new PointerTypeSymbol(TypeWithAnnotations.Create(fixedElementType)));
}
Interlocked.CompareExchange(ref _lazyType, new TypeWithAnnotations.Boxed(type), null);
}
}
public PEParameterSymbolWithCustomModifiers(
PEModuleSymbol moduleSymbol,
Symbol containingSymbol,
int ordinal,
bool isByRef,
ImmutableArray <ModifierInfo <TypeSymbol> > refCustomModifiers,
TypeWithAnnotations type,
ParameterHandle handle,
Symbol nullableContext,
out bool isBad
)
: base(
moduleSymbol,
containingSymbol,
ordinal,
isByRef,
type,
handle,
nullableContext,
refCustomModifiers.NullToEmpty().Length + type.CustomModifiers.Length,
out isBad
)
{
_refCustomModifiers = CSharpCustomModifier.Convert(refCustomModifiers);
Debug.Assert(_refCustomModifiers.IsEmpty || isByRef);
}
public void TypeMap()
{
var source = @"
struct S<T> where T : struct
{
}
";
var comp = CreateCompilation(source);
comp.VerifyDiagnostics();
var intType = comp.GetSpecialType(SpecialType.System_Int32);
var customModifiers = ImmutableArray.Create(CSharpCustomModifier.CreateOptional(intType));
var structType = comp.GlobalNamespace.GetMember <NamedTypeSymbol>("S");
var typeParamType = structType.TypeParameters.Single();
var pointerType = new PointerTypeSymbol(typeParamType, customModifiers); // NOTE: We're constructing this manually, since it's illegal.
var arrayType = ArrayTypeSymbol.CreateCSharpArray(comp.Assembly, typeParamType, customModifiers); // This is legal, but we're already manually constructing types.
var typeMap = new TypeMap(ImmutableArray.Create(typeParamType), ImmutableArray.Create(new TypeWithModifiers(intType)));
var substitutedPointerType = (PointerTypeSymbol)typeMap.SubstituteType(pointerType).AsTypeSymbolOnly();
var substitutedArrayType = (ArrayTypeSymbol)typeMap.SubstituteType(arrayType).AsTypeSymbolOnly();
// The map changed the types.
Assert.Equal(intType, substitutedPointerType.PointedAtType);
Assert.Equal(intType, substitutedArrayType.ElementType);
// The map preserved the custom modifiers.
Assert.Equal(customModifiers, substitutedPointerType.CustomModifiers);
Assert.Equal(customModifiers, substitutedArrayType.CustomModifiers);
}
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);
if (this.RefKind != RefKind.RefReadOnly && _refCustomModifiers.Any(modifier => !modifier.IsOptional && modifier.Modifier.IsWellKnownTypeInAttribute()))
{
// The modreq is only accepted on RefReadOnly symbols
isBad = true;
}
Debug.Assert(_refCustomModifiers.IsEmpty || isByRef);
}
private CustomModifier VisitCustomModifier(CustomModifier modifier)
{
var type = (NamedTypeSymbol)this.Visit((Symbol)modifier.Modifier);
Debug.Assert((object)type != null);
return modifier.IsOptional ?
CSharpCustomModifier.CreateOptional(type) :
CSharpCustomModifier.CreateRequired(type);
}
protected override TypeSymbol GetSZArrayTypeSymbol(TypeSymbol elementType, ImmutableArray <ModifierInfo> customModifiers)
{
if (elementType is UnsupportedMetadataTypeSymbol)
{
return(elementType);
}
return(new ArrayTypeSymbol(moduleSymbol.ContainingAssembly, elementType, CSharpCustomModifier.Convert(customModifiers)));
}
protected override TypeSymbol MakePointerTypeSymbol(TypeSymbol type, ImmutableArray <ModifierInfo> customModifiers)
{
if (type is UnsupportedMetadataTypeSymbol)
{
return(type);
}
return(new PointerTypeSymbol(type, CSharpCustomModifier.Convert(customModifiers)));
}
internal override TypeSymbol MakePointerTypeSymbol(PEModuleSymbol moduleSymbol, TypeSymbol type, ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers)
{
if (type is UnsupportedMetadataTypeSymbol)
{
return(type);
}
return(new PointerTypeSymbol(type, CSharpCustomModifier.Convert(customModifiers)));
}
IEnumerable <Cci.TypeReferenceWithAttributes> Cci.IGenericParameter.GetConstraints(EmitContext context)
{
var moduleBeingBuilt = (PEModuleBuilder)context.Module;
var seenValueType = false;
if (AdaptedTypeParameterSymbol.HasUnmanagedTypeConstraint)
{
var typeRef = moduleBeingBuilt.GetSpecialType(
SpecialType.System_ValueType,
syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNodeOpt,
diagnostics: context.Diagnostics);
var modifier = CSharpCustomModifier.CreateRequired(
moduleBeingBuilt.Compilation.GetWellKnownType(WellKnownType.System_Runtime_InteropServices_UnmanagedType));
// emit "(class [mscorlib]System.ValueType modreq([mscorlib]System.Runtime.InteropServices.UnmanagedType" pattern as "unmanaged"
yield return(new Cci.TypeReferenceWithAttributes(new Cci.ModifiedTypeReference(typeRef, ImmutableArray.Create <Cci.ICustomModifier>(modifier))));
// do not emit another one for Dev11 similarities
seenValueType = true;
}
foreach (var type in AdaptedTypeParameterSymbol.ConstraintTypesNoUseSiteDiagnostics)
{
switch (type.SpecialType)
{
case SpecialType.System_Object:
Debug.Assert(!type.NullableAnnotation.IsAnnotated());
break;
case SpecialType.System_ValueType:
seenValueType = true;
break;
}
var typeRef = moduleBeingBuilt.Translate(type.Type,
syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNodeOpt,
diagnostics: context.Diagnostics);
yield return(type.GetTypeRefWithAttributes(
moduleBeingBuilt,
declaringSymbol: AdaptedTypeParameterSymbol,
typeRef));
}
if (AdaptedTypeParameterSymbol.HasValueTypeConstraint && !seenValueType)
{
// Add System.ValueType constraint to comply with Dev11 output
var typeRef = moduleBeingBuilt.GetSpecialType(SpecialType.System_ValueType,
syntaxNodeOpt: (CSharpSyntaxNode)context.SyntaxNodeOpt,
diagnostics: context.Diagnostics);
yield return(new Cci.TypeReferenceWithAttributes(typeRef));
}
}
private static TypeWithAnnotations CreateType(
TypeSymbol type,
ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers
)
{
// The actual annotation will be set when these types are transformed by the caller.
return(TypeWithAnnotations.Create(
type,
NullableAnnotation.Oblivious,
CSharpCustomModifier.Convert(customModifiers)
));
}
public PEPropertySymbolWithCustomModifiers(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyDefinitionHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod,
ParamInfo <TypeSymbol>[] propertyParams,
MetadataDecoder metadataDecoder)
: base(moduleSymbol, containingType, handle, getMethod, setMethod,
propertyParams,
metadataDecoder)
{
var returnInfo = propertyParams[0];
_refCustomModifiers = CSharpCustomModifier.Convert(returnInfo.RefCustomModifiers);
}
internal override TypeSymbol GetArrayTypeSymbol(PEModuleSymbol moduleSymbol, int rank, TypeSymbol elementType, ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers)
{
if (elementType is UnsupportedMetadataTypeSymbol)
{
return(elementType);
}
if (rank == 1)
{
// We do not support multi-dimensional arrays of rank 1, cannot distinguish
// them from SZARRAY.
// TODO(ngafter): what is the correct diagnostic for this situation?
return(new UnsupportedMetadataTypeSymbol()); // Found a multi-dimensional array of rank 1 in metadata
}
return(new ArrayTypeSymbol(moduleSymbol.ContainingAssembly, elementType, CSharpCustomModifier.Convert(customModifiers), rank));
}
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);
}
public PEPropertySymbolWithCustomModifiers(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyDefinitionHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod,
ParamInfo <TypeSymbol>[] propertyParams,
MetadataDecoder metadataDecoder,
out bool isBad)
: base(moduleSymbol, containingType, handle, getMethod, setMethod,
propertyParams[0].CustomModifiers.NullToEmpty().Length + propertyParams[0].RefCustomModifiers.NullToEmpty().Length,
propertyParams, metadataDecoder)
{
var returnInfo = propertyParams[0];
_typeCustomModifiers = CSharpCustomModifier.Convert(returnInfo.CustomModifiers);
_refCustomModifiers = CSharpCustomModifier.Convert(returnInfo.RefCustomModifiers);
// The modreq is only accepted on RefReadOnly symbols
isBad = this.RefKind != RefKind.RefReadOnly && _refCustomModifiers.Any(modifier => !modifier.IsOptional && modifier.Modifier.IsWellKnownTypeInAttribute());
}
private void EnsureSignatureIsLoaded()
{
if (_lazyType == null)
{
var moduleSymbol = _containingType.ContainingPEModule;
ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers;
TypeSymbol typeSymbol = (new MetadataDecoder(moduleSymbol, _containingType)).DecodeFieldSignature(_handle, out customModifiers);
ImmutableArray <CustomModifier> customModifiersArray = CSharpCustomModifier.Convert(customModifiers);
typeSymbol = DynamicTypeDecoder.TransformType(typeSymbol, customModifiersArray.Length, _handle, moduleSymbol);
typeSymbol = NativeIntegerTypeDecoder.TransformType(typeSymbol, _handle, moduleSymbol, _containingType);
// We start without annotations
var type = TypeWithAnnotations.Create(typeSymbol, customModifiers: customModifiersArray);
// Decode nullable before tuple types to avoid converting between
// NamedTypeSymbol and TupleTypeSymbol unnecessarily.
type = NullableTypeDecoder.TransformType(type, _handle, moduleSymbol, accessSymbol: this, nullableContext: _containingType);
type = TupleTypeDecoder.DecodeTupleTypesIfApplicable(type, _handle, moduleSymbol);
_lazyIsVolatile = customModifiersArray.Any(static m => !m.IsOptional && ((CSharpCustomModifier)m).ModifierSymbol.SpecialType == SpecialType.System_Runtime_CompilerServices_IsVolatile);
private PEPropertySymbol(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyDefinitionHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod,
ParamInfo <TypeSymbol>[] propertyParams,
MetadataDecoder metadataDecoder)
{
_containingType = containingType;
var module = moduleSymbol.Module;
PropertyAttributes mdFlags = 0;
BadImageFormatException mrEx = null;
try
{
module.GetPropertyDefPropsOrThrow(handle, out _name, out mdFlags);
}
catch (BadImageFormatException e)
{
mrEx = e;
if ((object)_name == null)
{
_name = string.Empty;
}
}
_getMethod = getMethod;
_setMethod = setMethod;
_handle = handle;
SignatureHeader unusedCallingConvention;
BadImageFormatException getEx = null;
var getMethodParams = (object)getMethod == null ? null : metadataDecoder.GetSignatureForMethod(getMethod.Handle, out unusedCallingConvention, out getEx);
BadImageFormatException setEx = null;
var setMethodParams = (object)setMethod == null ? null : metadataDecoder.GetSignatureForMethod(setMethod.Handle, out unusedCallingConvention, out setEx);
// NOTE: property parameter names are not recorded in metadata, so we have to
// use the parameter names from one of the indexers
// NB: prefer setter names to getter names if both are present.
bool isBad;
_parameters = setMethodParams is null
? GetParameters(moduleSymbol, this, propertyParams, getMethodParams, getMethod.IsMetadataVirtual(), out isBad)
: GetParameters(moduleSymbol, this, propertyParams, setMethodParams, setMethod.IsMetadataVirtual(), out isBad);
if (getEx != null || setEx != null || mrEx != null || isBad)
{
_lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this);
}
var returnInfo = propertyParams[0];
var typeCustomModifiers = CSharpCustomModifier.Convert(returnInfo.CustomModifiers);
if (returnInfo.IsByRef)
{
if (moduleSymbol.Module.HasIsReadOnlyAttribute(handle))
{
_refKind = RefKind.RefReadOnly;
}
else
{
_refKind = RefKind.Ref;
}
}
else
{
_refKind = RefKind.None;
}
// CONSIDER: Can we make parameter type computation lazy?
TypeSymbol originalPropertyType = returnInfo.Type;
originalPropertyType = DynamicTypeDecoder.TransformType(originalPropertyType, typeCustomModifiers.Length, handle, moduleSymbol, _refKind);
originalPropertyType = NativeIntegerTypeDecoder.TransformType(originalPropertyType, handle, moduleSymbol);
// Dynamify object type if necessary
originalPropertyType = originalPropertyType.AsDynamicIfNoPia(_containingType);
// We start without annotation (they will be decoded below)
var propertyTypeWithAnnotations = TypeWithAnnotations.Create(originalPropertyType, customModifiers: typeCustomModifiers);
// Decode nullable before tuple types to avoid converting between
// NamedTypeSymbol and TupleTypeSymbol unnecessarily.
// The containing type is passed to NullableTypeDecoder.TransformType to determine access
// because the property does not have explicit accessibility in metadata.
propertyTypeWithAnnotations = NullableTypeDecoder.TransformType(propertyTypeWithAnnotations, handle, moduleSymbol, accessSymbol: _containingType, nullableContext: _containingType);
propertyTypeWithAnnotations = TupleTypeDecoder.DecodeTupleTypesIfApplicable(propertyTypeWithAnnotations, handle, moduleSymbol);
_propertyTypeWithAnnotations = propertyTypeWithAnnotations;
// A property is bogus and must be accessed by calling its accessors directly if the
// accessor signatures do not agree, both with each other and with the property,
// or if it has parameters and is not an indexer or indexed property.
bool callMethodsDirectly = !DoSignaturesMatch(module, metadataDecoder, propertyParams, _getMethod, getMethodParams, _setMethod, setMethodParams) ||
MustCallMethodsDirectlyCore();
if (!callMethodsDirectly)
{
if ((object)_getMethod != null)
{
_getMethod.SetAssociatedProperty(this, MethodKind.PropertyGet);
}
if ((object)_setMethod != null)
{
_setMethod.SetAssociatedProperty(this, MethodKind.PropertySet);
}
}
if (callMethodsDirectly)
{
_flags |= Flags.CallMethodsDirectly;
}
if ((mdFlags & PropertyAttributes.SpecialName) != 0)
{
_flags |= Flags.IsSpecialName;
}
if ((mdFlags & PropertyAttributes.RTSpecialName) != 0)
{
_flags |= Flags.IsRuntimeSpecialName;
}
}
internal override TypeSymbol GetMDArrayTypeSymbol(PEModuleSymbol moduleSymbol, int rank, TypeSymbol elementType, ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers,
ImmutableArray <int> sizes, ImmutableArray <int> lowerBounds)
{
if (elementType is UnsupportedMetadataTypeSymbol)
{
return(elementType);
}
return(ArrayTypeSymbol.CreateMDArray(moduleSymbol.ContainingAssembly, elementType, rank, sizes, lowerBounds, CSharpCustomModifier.Convert(customModifiers)));
}
internal PEPropertySymbol(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyDefinitionHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingType != null);
Debug.Assert(!handle.IsNil);
_containingType = containingType;
var module = moduleSymbol.Module;
PropertyAttributes mdFlags = 0;
BadImageFormatException mrEx = null;
try
{
module.GetPropertyDefPropsOrThrow(handle, out _name, out mdFlags);
}
catch (BadImageFormatException e)
{
mrEx = e;
if ((object)_name == null)
{
_name = string.Empty;
}
}
_getMethod = getMethod;
_setMethod = setMethod;
_handle = handle;
var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType);
SignatureHeader callingConvention;
BadImageFormatException propEx;
var propertyParams = metadataDecoder.GetSignatureForProperty(handle, out callingConvention, out propEx, allowByRefReturn: true);
Debug.Assert(propertyParams.Length > 0);
SignatureHeader unusedCallingConvention;
BadImageFormatException getEx = null;
var getMethodParams = (object)getMethod == null ? null : metadataDecoder.GetSignatureForMethod(getMethod.Handle, out unusedCallingConvention, out getEx, allowByRefReturn: true);
BadImageFormatException setEx = null;
var setMethodParams = (object)setMethod == null ? null : metadataDecoder.GetSignatureForMethod(setMethod.Handle, out unusedCallingConvention, out setEx, allowByRefReturn: false);
// NOTE: property parameter names are not recorded in metadata, so we have to
// use the parameter names from one of the indexers
// NB: prefer setter names to getter names if both are present.
bool isBad;
_parameters = GetParameters(moduleSymbol, this, propertyParams, setMethodParams ?? getMethodParams, out isBad);
if (propEx != null || getEx != null || setEx != null || mrEx != null || isBad)
{
_lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this);
}
_typeCustomModifiers = CSharpCustomModifier.Convert(propertyParams[0].CustomModifiers);
_refKind = propertyParams[0].IsByRef ? RefKind.Ref : RefKind.None;
// CONSIDER: Can we make parameter type computation lazy?
TypeSymbol originalPropertyType = propertyParams[0].Type;
_propertyType = DynamicTypeDecoder.TransformType(originalPropertyType, _typeCustomModifiers.Length, handle, moduleSymbol);
// Dynamify object type if necessary
_propertyType = _propertyType.AsDynamicIfNoPia(_containingType);
_propertyType = TupleTypeDecoder.DecodeTupleTypesIfApplicable(_propertyType, handle, moduleSymbol);
// A property is bogus and must be accessed by calling its accessors directly if the
// accessor signatures do not agree, both with each other and with the property,
// or if it has parameters and is not an indexer or indexed property.
bool callMethodsDirectly = !DoSignaturesMatch(module, metadataDecoder, propertyParams, _getMethod, getMethodParams, _setMethod, setMethodParams) ||
MustCallMethodsDirectlyCore();
if (!callMethodsDirectly)
{
if ((object)_getMethod != null)
{
_getMethod.SetAssociatedProperty(this, MethodKind.PropertyGet);
}
if ((object)_setMethod != null)
{
_setMethod.SetAssociatedProperty(this, MethodKind.PropertySet);
}
}
if (callMethodsDirectly)
{
_flags |= Flags.CallMethodsDirectly;
}
if ((mdFlags & PropertyAttributes.SpecialName) != 0)
{
_flags |= Flags.IsSpecialName;
}
if ((mdFlags & PropertyAttributes.RTSpecialName) != 0)
{
_flags |= Flags.IsRuntimeSpecialName;
}
}
internal override TypeSymbol GetSZArrayTypeSymbol(PEModuleSymbol moduleSymbol, TypeSymbol elementType, ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers)
{
if (elementType is UnsupportedMetadataTypeSymbol)
{
return(elementType);
}
return(ArrayTypeSymbol.CreateSZArray(moduleSymbol.ContainingAssembly, elementType, CSharpCustomModifier.Convert(customModifiers)));
}
private static PEParameterSymbol Create(
PEModuleSymbol moduleSymbol,
Symbol containingSymbol,
bool isContainingSymbolVirtual,
int ordinal,
bool isByRef,
ImmutableArray <ModifierInfo <TypeSymbol> > refCustomModifiers,
TypeSymbol type,
ParameterHandle handle,
Symbol nullableContext,
ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers,
bool isReturn,
out bool isBad)
{
// We start without annotation (they will be decoded below)
var typeWithModifiers = TypeWithAnnotations.Create(type, customModifiers: CSharpCustomModifier.Convert(customModifiers));
PEParameterSymbol parameter = customModifiers.IsDefaultOrEmpty && refCustomModifiers.IsDefaultOrEmpty
? new PEParameterSymbol(moduleSymbol, containingSymbol, ordinal, isByRef, typeWithModifiers, handle, nullableContext, 0, out isBad)
: new PEParameterSymbolWithCustomModifiers(moduleSymbol, containingSymbol, ordinal, isByRef, refCustomModifiers, typeWithModifiers, handle, nullableContext, out isBad);
bool hasInAttributeModifier = parameter.RefCustomModifiers.HasInAttributeModifier();
if (isReturn)
{
// A RefReadOnly return parameter should always have this modreq, and vice versa.
isBad |= (parameter.RefKind == RefKind.RefReadOnly) != hasInAttributeModifier;
}
else if (parameter.RefKind == RefKind.In)
{
// An in parameter should not have this modreq, unless the containing symbol was virtual or abstract.
isBad |= isContainingSymbolVirtual != hasInAttributeModifier;
}
else if (hasInAttributeModifier)
{
// This modreq should not exist on non-in parameters.
isBad = true;
}
return(parameter);
}
internal override TypeSymbol SubstituteTypeParameters(
PEModuleSymbol moduleSymbol,
TypeSymbol genericTypeDef,
ImmutableArray <KeyValuePair <TypeSymbol, ImmutableArray <ModifierInfo <TypeSymbol> > > > arguments,
ImmutableArray <bool> refersToNoPiaLocalType)
{
if (genericTypeDef is UnsupportedMetadataTypeSymbol)
{
return(genericTypeDef);
}
// Let's return unsupported metadata type if any argument is unsupported metadata type
foreach (var arg in arguments)
{
if (arg.Key.Kind == SymbolKind.ErrorType &&
arg.Key is UnsupportedMetadataTypeSymbol)
{
return(new UnsupportedMetadataTypeSymbol());
}
}
NamedTypeSymbol genericType = (NamedTypeSymbol)genericTypeDef;
// See if it is or its enclosing type is a non-interface closed over NoPia local types.
ImmutableArray <AssemblySymbol> linkedAssemblies = moduleSymbol.ContainingAssembly.GetLinkedReferencedAssemblies();
bool noPiaIllegalGenericInstantiation = false;
if (!linkedAssemblies.IsDefaultOrEmpty || moduleSymbol.Module.ContainsNoPiaLocalTypes())
{
NamedTypeSymbol typeToCheck = genericType;
int argumentIndex = refersToNoPiaLocalType.Length - 1;
do
{
if (!typeToCheck.IsInterface)
{
break;
}
else
{
argumentIndex -= typeToCheck.Arity;
}
typeToCheck = typeToCheck.ContainingType;
}while ((object)typeToCheck != null);
for (int i = argumentIndex; i >= 0; i--)
{
if (refersToNoPiaLocalType[i] ||
(!linkedAssemblies.IsDefaultOrEmpty &&
MetadataDecoder.IsOrClosedOverATypeFromAssemblies(arguments[i].Key, linkedAssemblies)))
{
noPiaIllegalGenericInstantiation = true;
break;
}
}
}
// Collect generic parameters for the type and its containers in the order
// that matches passed in arguments, i.e. sorted by the nesting.
ImmutableArray <TypeParameterSymbol> typeParameters = genericType.GetAllTypeParameters();
Debug.Assert(typeParameters.Length > 0);
if (typeParameters.Length != arguments.Length)
{
return(new UnsupportedMetadataTypeSymbol());
}
TypeMap substitution = new TypeMap(typeParameters, arguments.SelectAsArray(arg => new TypeWithModifiers(arg.Key, CSharpCustomModifier.Convert(arg.Value))));
NamedTypeSymbol constructedType = substitution.SubstituteNamedType(genericType);
if (noPiaIllegalGenericInstantiation)
{
constructedType = new NoPiaIllegalGenericInstantiationSymbol(moduleSymbol, constructedType);
}
return(constructedType);
}
private static TypeSymbolWithAnnotations CreateType(TypeSymbol type, ImmutableArray <ModifierInfo <TypeSymbol> > customModifiers)
{
// NonNullTypesContext is unset because the actual context will
// be set when these types are transformed by the caller.
return(TypeSymbolWithAnnotations.Create(NonNullTypesNullContext.Instance, type, customModifiers: CSharpCustomModifier.Convert(customModifiers)));
}
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);
}