internal PETypeParameterSymbol(
PEModuleSymbol moduleSymbol,
PEMethodSymbol definingMethod,
ushort ordinal,
GenericParameterHandle handle)
: this(moduleSymbol, (Symbol)definingMethod, ordinal, handle)
{
}
internal PEParameterSymbol(
PEModuleSymbol moduleSymbol,
PEMethodSymbol containingSymbol,
int ordinal,
MetadataDecoder.ParamInfo parameter,
out bool isBad)
: this(moduleSymbol, containingSymbol, ordinal, parameter.IsByRef, parameter.HasByRefBeforeCustomModifiers, parameter.Type, parameter.Handle, parameter.CustomModifiers, out isBad)
{
}
internal static PEPropertySymbol Create(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyDefinitionHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingType != null);
Debug.Assert(!handle.IsNil);
var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType);
SignatureHeader callingConvention;
BadImageFormatException propEx;
var propertyParams = metadataDecoder.GetSignatureForProperty(handle, out callingConvention, out propEx);
Debug.Assert(propertyParams.Length > 0);
var returnInfo = propertyParams[0];
PEPropertySymbol result;
if (returnInfo.CustomModifiers.IsDefaultOrEmpty && returnInfo.RefCustomModifiers.IsDefaultOrEmpty)
{
result = new PEPropertySymbol(moduleSymbol, containingType, handle, getMethod, setMethod, 0, propertyParams, metadataDecoder);
}
else
{
result = new PEPropertySymbolWithCustomModifiers(moduleSymbol, containingType, handle, getMethod, setMethod, propertyParams, metadataDecoder);
}
if (propEx != null)
{
result._lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, result);
}
return result;
}
public MetadataDecoder(
PEModuleSymbol moduleSymbol,
PEMethodSymbol context) :
this(moduleSymbol, (PENamedTypeSymbol)context.ContainingType, context)
{
}
internal PEEventSymbol(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
EventHandle handle,
PEMethodSymbol addMethod,
PEMethodSymbol removeMethod)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingType != null);
Debug.Assert(!handle.IsNil);
Debug.Assert((object)addMethod != null);
Debug.Assert((object)removeMethod != null);
this.addMethod = addMethod;
this.removeMethod = removeMethod;
this.handle = handle;
this.containingType = containingType;
EventAttributes mdFlags = 0;
Handle eventType = default(Handle);
try
{
var module = moduleSymbol.Module;
module.GetEventDefPropsOrThrow(handle, out this.name, out mdFlags, out eventType);
}
catch (BadImageFormatException mrEx)
{
if ((object)this.name == null)
{
this.name = string.Empty;
}
lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this);
if (eventType.IsNil)
{
this.eventType = new UnsupportedMetadataTypeSymbol(mrEx);
}
}
if ((object)this.eventType == null)
{
var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType);
this.eventType = metadataDecoder.GetTypeOfToken(eventType);
}
// IsWindowsRuntimeEvent checks the signatures, so we just have to check the accessors.
bool callMethodsDirectly = IsWindowsRuntimeEvent
? !DoModifiersMatch(this.addMethod, this.removeMethod)
: !DoSignaturesMatch(moduleSymbol, this.eventType, this.addMethod, this.removeMethod);
if (callMethodsDirectly)
{
flags |= Flags.CallMethodsDirectly;
}
else
{
this.addMethod.SetAssociatedEvent(this, MethodKind.EventAdd);
this.removeMethod.SetAssociatedEvent(this, MethodKind.EventRemove);
}
if ((mdFlags & EventAttributes.SpecialName) != 0)
{
flags |= Flags.IsSpecialName;
}
if ((mdFlags & EventAttributes.RTSpecialName) != 0)
{
flags |= Flags.IsRuntimeSpecialName;
}
}
private static bool DoesSignatureMatch(
PEModuleSymbol moduleSymbol,
TypeSymbol eventType,
PEMethodSymbol method)
{
// CONSIDER: It would be nice if we could reuse this signature information in the PEMethodSymbol.
var metadataDecoder = new MetadataDecoder(moduleSymbol, method);
SignatureHeader signatureHeader;
BadImageFormatException mrEx;
var methodParams = metadataDecoder.GetSignatureForMethod(method.Handle, out signatureHeader, out mrEx, setParamHandles: false);
if (mrEx != null)
{
return false;
}
return metadataDecoder.DoesSignatureMatchEvent(eventType, methodParams);
}
private static bool DoSignaturesMatch(
PEModuleSymbol moduleSymbol,
TypeSymbol eventType,
PEMethodSymbol addMethod,
PEMethodSymbol removeMethod)
{
return
(eventType.IsDelegateType() || eventType.IsErrorType()) &&
DoesSignatureMatch(moduleSymbol, eventType, addMethod) &&
DoesSignatureMatch(moduleSymbol, eventType, removeMethod) &&
DoModifiersMatch(addMethod, removeMethod);
}
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 PEPropertySymbol(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingType != null);
Debug.Assert(!handle.IsNil);
this.containingType = containingType;
var module = moduleSymbol.Module;
PropertyAttributes mdFlags = 0;
BadImageFormatException mrEx = null;
try
{
module.GetPropertyDefPropsOrThrow(handle, out this.name, out mdFlags);
}
catch (BadImageFormatException e)
{
mrEx = e;
if ((object)this.name == null)
{
this.name = string.Empty;
}
}
this.getMethod = getMethod;
this.setMethod = setMethod;
this.handle = handle;
var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType);
byte callingConvention;
BadImageFormatException propEx;
var propertyParams = metadataDecoder.GetSignatureForProperty(handle, out callingConvention, out propEx);
Debug.Assert(propertyParams.Length > 0);
byte 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;
this.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);
}
this.typeCustomModifiers = CSharpCustomModifier.Convert(propertyParams[0].CustomModifiers);
// CONSIDER: Can we make parameter type computation lazy?
TypeSymbol originalPropertyType = propertyParams[0].Type;
this.propertyType = DynamicTypeDecoder.TransformType(originalPropertyType, typeCustomModifiers.Length, handle, moduleSymbol);
// Dynamify object type if necessary
this.propertyType = this.propertyType.AsDynamicIfNoPia(this.containingType);
// 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, this.getMethod, getMethodParams, this.setMethod, setMethodParams) ||
MustCallMethodsDirectlyCore();
if (!callMethodsDirectly)
{
if ((object)this.getMethod != null)
{
this.getMethod.SetAssociatedProperty(this, MethodKind.PropertyGet);
}
if ((object)this.setMethod != null)
{
this.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 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;
}
}
private PEPropertySymbol(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyDefinitionHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod,
int countOfCustomModifiers,
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 = GetParameters(moduleSymbol, this, propertyParams, setMethodParams ?? getMethodParams, out isBad);
if (getEx != null || setEx != null || mrEx != null || isBad)
{
_lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this);
}
var returnInfo = propertyParams[0];
_refKind = returnInfo.IsByRef ? RefKind.Ref : RefKind.None;
// CONSIDER: Can we make parameter type computation lazy?
TypeSymbol originalPropertyType = returnInfo.Type;
_propertyType = DynamicTypeDecoder.TransformType(originalPropertyType, countOfCustomModifiers, handle, moduleSymbol, _refKind);
// 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;
}
}
public PEPropertySymbolWithCustomModifiers(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyDefinitionHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod,
ParamInfo<TypeSymbol>[] propertyParams,
MetadataDecoder metadataDecoder)
: 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);
}
/// <summary>
/// </summary>
/// <param name="peModuleSymbol">
/// </param>
/// <param name="peMethodSymbol">
/// </param>
private void GetPEMethodSymbol(out PEModuleSymbol peModuleSymbol, out PEMethodSymbol peMethodSymbol)
{
peModuleSymbol = this.methodDef.ContainingModule as PEModuleSymbol;
peMethodSymbol = this.methodDef as PEMethodSymbol;
if (peMethodSymbol == null)
{
peMethodSymbol = this.methodDef.OriginalDefinition as PEMethodSymbol;
}
}
/// <summary>
/// </summary>
/// <param name="peModuleSymbol">
/// </param>
/// <param name="peMethodSymbol">
/// </param>
/// <returns>
/// </returns>
private MethodBodyBlock GetMethodBodyBlock(PEModuleSymbol peModuleSymbol, PEMethodSymbol peMethodSymbol)
{
var peModule = peModuleSymbol.Module;
if (peMethodSymbol != null)
{
Debug.Assert(peModule.HasIL);
lock (peModuleSymbol)
{
return peModule.GetMethodBodyOrThrow(peMethodSymbol.Handle);
}
}
return null;
}
internal PEEventSymbol(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
EventDefinitionHandle handle,
PEMethodSymbol addMethod,
PEMethodSymbol removeMethod,
MultiDictionary <string, PEFieldSymbol> privateFieldNameToSymbols)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingType != null);
Debug.Assert(!handle.IsNil);
Debug.Assert((object)addMethod != null);
Debug.Assert((object)removeMethod != null);
this.addMethod = addMethod;
this.removeMethod = removeMethod;
this.handle = handle;
this.containingType = containingType;
EventAttributes mdFlags = 0;
Handle eventType = default(Handle);
try
{
var module = moduleSymbol.Module;
module.GetEventDefPropsOrThrow(handle, out this.name, out mdFlags, out eventType);
}
catch (BadImageFormatException mrEx)
{
if ((object)this.name == null)
{
this.name = string.Empty;
}
lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this);
if (eventType.IsNil)
{
this.eventType = new UnsupportedMetadataTypeSymbol(mrEx);
}
}
if ((object)this.eventType == null)
{
var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType);
this.eventType = metadataDecoder.GetTypeOfToken(eventType);
}
// IsWindowsRuntimeEvent checks the signatures, so we just have to check the accessors.
bool isWindowsRuntimeEvent = IsWindowsRuntimeEvent;
bool callMethodsDirectly = isWindowsRuntimeEvent
? !DoModifiersMatch(this.addMethod, this.removeMethod)
: !DoSignaturesMatch(moduleSymbol, this.eventType, this.addMethod, this.removeMethod);
if (callMethodsDirectly)
{
flags |= Flags.CallMethodsDirectly;
}
else
{
this.addMethod.SetAssociatedEvent(this, MethodKind.EventAdd);
this.removeMethod.SetAssociatedEvent(this, MethodKind.EventRemove);
PEFieldSymbol associatedField = GetAssociatedField(privateFieldNameToSymbols, isWindowsRuntimeEvent);
if ((object)associatedField != null)
{
this.associatedFieldOpt = associatedField;
associatedField.SetAssociatedEvent(this);
}
}
if ((mdFlags & EventAttributes.SpecialName) != 0)
{
flags |= Flags.IsSpecialName;
}
if ((mdFlags & EventAttributes.RTSpecialName) != 0)
{
flags |= Flags.IsRuntimeSpecialName;
}
}
private MetadataDecoder(PEModuleSymbol moduleSymbol, PENamedTypeSymbol typeContextOpt, PEMethodSymbol methodContextOpt)
// TODO (tomat): if the containing assembly is a source assembly and we are about to decode assembly level attributes, we run into a cycle,
// so for now ignore the assembly identity.
: base(moduleSymbol.Module, (moduleSymbol.ContainingAssembly is PEAssemblySymbol) ? moduleSymbol.ContainingAssembly.Identity : null, SymbolFactory.Instance, moduleSymbol)
{
Debug.Assert((object)moduleSymbol != null);
_typeContextOpt = typeContextOpt;
_methodContextOpt = methodContextOpt;
}
private ImmutableArray <TypeSymbol> GetDeclaredConstraintTypes()
{
PEMethodSymbol containingMethod = null;
PENamedTypeSymbol containingType;
if (_containingSymbol.Kind == SymbolKind.Method)
{
containingMethod = (PEMethodSymbol)_containingSymbol;
containingType = (PENamedTypeSymbol)containingMethod.ContainingSymbol;
}
else
{
containingType = (PENamedTypeSymbol)_containingSymbol;
}
var moduleSymbol = containingType.ContainingPEModule;
var metadataReader = moduleSymbol.Module.MetadataReader;
GenericParameterConstraintHandleCollection constraints;
try
{
constraints = metadataReader.GetGenericParameter(_handle).GetConstraints();
}
catch (BadImageFormatException)
{
constraints = default(GenericParameterConstraintHandleCollection);
Interlocked.CompareExchange(ref _lazyBoundsErrorInfo, new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this), CSDiagnosticInfo.EmptyErrorInfo);
}
if (constraints.Count > 0)
{
var symbolsBuilder = ArrayBuilder <TypeSymbol> .GetInstance();
MetadataDecoder tokenDecoder;
if ((object)containingMethod != null)
{
tokenDecoder = new MetadataDecoder(moduleSymbol, containingMethod);
}
else
{
tokenDecoder = new MetadataDecoder(moduleSymbol, containingType);
}
foreach (var constraintHandle in constraints)
{
var constraint = metadataReader.GetGenericParameterConstraint(constraintHandle);
var constraintTypeHandle = constraint.Type;
TypeSymbol typeSymbol = tokenDecoder.GetTypeOfToken(constraintTypeHandle);
// Drop 'System.Object' constraint type.
if (typeSymbol.SpecialType == SpecialType.System_Object)
{
continue;
}
// Drop 'System.ValueType' constraint type if the 'valuetype' constraint was also specified.
if (((_flags & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0) &&
(typeSymbol.SpecialType == SpecialType.System_ValueType))
{
continue;
}
typeSymbol = TupleTypeDecoder.DecodeTupleTypesIfApplicable(typeSymbol,
constraintHandle,
moduleSymbol);
symbolsBuilder.Add(typeSymbol);
}
return(symbolsBuilder.ToImmutableAndFree());
}
else
{
return(ImmutableArray <TypeSymbol> .Empty);
}
}
internal PEEventSymbol(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
EventDefinitionHandle handle,
PEMethodSymbol addMethod,
PEMethodSymbol removeMethod,
MultiDictionary <string, PEFieldSymbol> privateFieldNameToSymbols)
{
RoslynDebug.Assert((object)moduleSymbol != null);
RoslynDebug.Assert((object)containingType != null);
Debug.Assert(!handle.IsNil);
RoslynDebug.Assert((object)addMethod != null);
RoslynDebug.Assert((object)removeMethod != null);
_addMethod = addMethod;
_removeMethod = removeMethod;
_handle = handle;
_containingType = containingType;
EventAttributes mdFlags = 0;
EntityHandle eventType = default(EntityHandle);
try
{
var module = moduleSymbol.Module;
module.GetEventDefPropsOrThrow(handle, out _name, out mdFlags, out eventType);
}
catch (BadImageFormatException mrEx)
{
_name = _name ?? string.Empty;
_lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this);
if (eventType.IsNil)
{
_eventTypeWithAnnotations = TypeWithAnnotations.Create(new UnsupportedMetadataTypeSymbol(mrEx));
}
}
TypeSymbol originalEventType = _eventTypeWithAnnotations.Type;
if (!_eventTypeWithAnnotations.HasType)
{
var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType);
originalEventType = metadataDecoder.GetTypeOfToken(eventType);
const int targetSymbolCustomModifierCount = 0;
var typeSymbol = DynamicTypeDecoder.TransformType(originalEventType, targetSymbolCustomModifierCount, handle, moduleSymbol);
// We start without annotation (they will be decoded below)
var type = TypeWithAnnotations.Create(typeSymbol);
// 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 event does not have explicit accessibility in metadata.
type = NullableTypeDecoder.TransformType(type, handle, moduleSymbol, accessSymbol: _containingType, nullableContext: _containingType);
type = TupleTypeDecoder.DecodeTupleTypesIfApplicable(type, handle, moduleSymbol);
_eventTypeWithAnnotations = type;
}
// IsWindowsRuntimeEvent checks the signatures, so we just have to check the accessors.
bool isWindowsRuntimeEvent = IsWindowsRuntimeEvent;
bool callMethodsDirectly = isWindowsRuntimeEvent
? !DoModifiersMatch(_addMethod, _removeMethod)
: !DoSignaturesMatch(moduleSymbol, originalEventType, _addMethod, _removeMethod);
if (callMethodsDirectly)
{
_flags |= Flags.CallMethodsDirectly;
}
else
{
_addMethod.SetAssociatedEvent(this, MethodKind.EventAdd);
_removeMethod.SetAssociatedEvent(this, MethodKind.EventRemove);
PEFieldSymbol?associatedField = GetAssociatedField(privateFieldNameToSymbols, isWindowsRuntimeEvent);
if ((object?)associatedField != null)
{
_associatedFieldOpt = associatedField;
associatedField.SetAssociatedEvent(this);
}
}
if ((mdFlags & EventAttributes.SpecialName) != 0)
{
_flags |= Flags.IsSpecialName;
}
if ((mdFlags & EventAttributes.RTSpecialName) != 0)
{
_flags |= Flags.IsRuntimeSpecialName;
}
}
internal static PEParameterSymbol Create(
PEModuleSymbol moduleSymbol,
PEMethodSymbol containingSymbol,
int ordinal,
ParamInfo<TypeSymbol> parameter,
out bool isBad)
{
return Create(moduleSymbol, containingSymbol, ordinal, parameter.IsByRef, parameter.CountOfCustomModifiersPrecedingByRef, parameter.Type, parameter.Handle, parameter.CustomModifiers, out isBad);
}
private ImmutableArray <TypeSymbol> GetDeclaredConstraintTypes()
{
PEMethodSymbol containingMethod = null;
PENamedTypeSymbol containingType;
if (_containingSymbol.Kind == SymbolKind.Method)
{
containingMethod = (PEMethodSymbol)_containingSymbol;
containingType = (PENamedTypeSymbol)containingMethod.ContainingSymbol;
}
else
{
containingType = (PENamedTypeSymbol)_containingSymbol;
}
var moduleSymbol = containingType.ContainingPEModule;
EntityHandle[] constraints;
try
{
constraints = moduleSymbol.Module.GetGenericParamConstraintsOrThrow(_handle);
}
catch (BadImageFormatException)
{
constraints = null;
Interlocked.CompareExchange(ref _lazyBoundsErrorInfo, new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this), CSDiagnosticInfo.EmptyErrorInfo);
}
if (constraints != null && constraints.Length > 0)
{
var symbolsBuilder = ArrayBuilder <TypeSymbol> .GetInstance();
MetadataDecoder tokenDecoder;
if ((object)containingMethod != null)
{
tokenDecoder = new MetadataDecoder(moduleSymbol, containingMethod);
}
else
{
tokenDecoder = new MetadataDecoder(moduleSymbol, containingType);
}
foreach (var constraint in constraints)
{
TypeSymbol typeSymbol = tokenDecoder.GetTypeOfToken(constraint);
// Drop 'System.Object' constraint type.
if (typeSymbol.SpecialType == Microsoft.CodeAnalysis.SpecialType.System_Object)
{
continue;
}
// Drop 'System.ValueType' constraint type if the 'valuetype' constraint was also specified.
if (((_flags & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0) &&
(typeSymbol.SpecialType == Microsoft.CodeAnalysis.SpecialType.System_ValueType))
{
continue;
}
symbolsBuilder.Add(typeSymbol);
}
return(symbolsBuilder.ToImmutableAndFree());
}
else
{
return(ImmutableArray <TypeSymbol> .Empty);
}
}
private static bool DoSignaturesMatch(
PEModule module,
MetadataDecoder metadataDecoder,
MetadataDecoder.ParamInfo[] propertyParams,
PEMethodSymbol getMethod,
MetadataDecoder.ParamInfo[] getMethodParams,
PEMethodSymbol setMethod,
MetadataDecoder.ParamInfo[] setMethodParams)
{
Debug.Assert((getMethodParams == null) == ((object)getMethod == null));
Debug.Assert((setMethodParams == null) == ((object)setMethod == null));
bool hasGetMethod = getMethodParams != null;
bool hasSetMethod = setMethodParams != null;
if (hasGetMethod && !metadataDecoder.DoPropertySignaturesMatch(propertyParams, getMethodParams, comparingToSetter: false, compareParamByRef: true, compareReturnType: true))
{
return false;
}
if (hasSetMethod && !metadataDecoder.DoPropertySignaturesMatch(propertyParams, setMethodParams, comparingToSetter: true, compareParamByRef: true, compareReturnType: true))
{
return false;
}
if (hasGetMethod && hasSetMethod)
{
var lastPropertyParamIndex = propertyParams.Length - 1;
var getHandle = getMethodParams[lastPropertyParamIndex].Handle;
var setHandle = setMethodParams[lastPropertyParamIndex].Handle;
var getterHasParamArray = !getHandle.IsNil && module.HasParamsAttribute(getHandle);
var setterHasParamArray = !setHandle.IsNil && module.HasParamsAttribute(setHandle);
if (getterHasParamArray != setterHasParamArray)
{
return false;
}
if ((getMethod.IsExtern != setMethod.IsExtern) ||
// (getMethod.IsAbstract != setMethod.IsAbstract) || // NOTE: Dev10 accepts one abstract accessor
(getMethod.IsSealed != setMethod.IsSealed) ||
(getMethod.IsOverride != setMethod.IsOverride) ||
(getMethod.IsStatic != setMethod.IsStatic))
{
return false;
}
}
return true;
}
internal static PEPropertySymbol Create(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyDefinitionHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod
)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingType != null);
Debug.Assert(!handle.IsNil);
var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType);
SignatureHeader callingConvention;
BadImageFormatException propEx;
var propertyParams = metadataDecoder.GetSignatureForProperty(
handle,
out callingConvention,
out propEx
);
Debug.Assert(propertyParams.Length > 0);
var returnInfo = propertyParams[0];
PEPropertySymbol result =
returnInfo.CustomModifiers.IsDefaultOrEmpty &&
returnInfo.RefCustomModifiers.IsDefaultOrEmpty
? new PEPropertySymbol(
moduleSymbol,
containingType,
handle,
getMethod,
setMethod,
propertyParams,
metadataDecoder
)
: new PEPropertySymbolWithCustomModifiers(
moduleSymbol,
containingType,
handle,
getMethod,
setMethod,
propertyParams,
metadataDecoder
);
// A property should always have this modreq, and vice versa.
var isBad =
(result.RefKind == RefKind.In)
!= result.RefCustomModifiers.HasInAttributeModifier();
if (propEx != null || isBad)
{
result._lazyCachedUseSiteInfo.Initialize(
new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, result)
);
}
return(result);
}
private ImmutableArray <TypeWithAnnotations> GetDeclaredConstraintTypes()
{
if (_lazyDeclaredConstraintTypes.IsDefault)
{
ImmutableArray <TypeWithAnnotations> declaredConstraintTypes;
PEMethodSymbol containingMethod = null;
PENamedTypeSymbol containingType;
if (_containingSymbol.Kind == SymbolKind.Method)
{
containingMethod = (PEMethodSymbol)_containingSymbol;
containingType = (PENamedTypeSymbol)containingMethod.ContainingSymbol;
}
else
{
containingType = (PENamedTypeSymbol)_containingSymbol;
}
var moduleSymbol = containingType.ContainingPEModule;
PEModule peModule = moduleSymbol.Module;
GenericParameterConstraintHandleCollection constraints = GetConstraintHandleCollection(peModule);
bool hasUnmanagedModreqPattern = false;
if (constraints.Count > 0)
{
var symbolsBuilder = ArrayBuilder <TypeWithAnnotations> .GetInstance();
MetadataDecoder tokenDecoder;
if ((object)containingMethod != null)
{
tokenDecoder = new MetadataDecoder(moduleSymbol, containingMethod);
}
else
{
tokenDecoder = new MetadataDecoder(moduleSymbol, containingType);
}
var metadataReader = peModule.MetadataReader;
foreach (var constraintHandle in constraints)
{
var constraint = metadataReader.GetGenericParameterConstraint(constraintHandle);
var typeSymbol = tokenDecoder.DecodeGenericParameterConstraint(constraint.Type, out bool hasUnmanagedModreq);
if (typeSymbol.SpecialType == SpecialType.System_ValueType)
{
// recognize "(class [mscorlib]System.ValueType modreq([mscorlib]System.Runtime.InteropServices.UnmanagedType" pattern as "unmanaged"
if (hasUnmanagedModreq)
{
hasUnmanagedModreqPattern = true;
}
// Drop 'System.ValueType' constraint type if the 'valuetype' constraint was also specified.
if (((_flags & GenericParameterAttributes.NotNullableValueTypeConstraint) != 0))
{
continue;
}
}
var type = TypeWithAnnotations.Create(typeSymbol);
type = NullableTypeDecoder.TransformType(type, constraintHandle, moduleSymbol);
// Drop 'System.Object?' constraint type.
if (type.SpecialType == SpecialType.System_Object && type.NullableAnnotation.IsAnnotated())
{
continue;
}
type = TupleTypeDecoder.DecodeTupleTypesIfApplicable(type, constraintHandle, moduleSymbol);
symbolsBuilder.Add(type);
}
declaredConstraintTypes = symbolsBuilder.ToImmutableAndFree();
}
else
{
declaredConstraintTypes = ImmutableArray <TypeWithAnnotations> .Empty;
}
// - presence of unmanaged pattern has to be matched with `valuetype`
// - IsUnmanagedAttribute is allowed iif there is an unmanaged pattern
if (hasUnmanagedModreqPattern && (_flags & GenericParameterAttributes.NotNullableValueTypeConstraint) == 0 ||
hasUnmanagedModreqPattern != peModule.HasIsUnmanagedAttribute(_handle))
{
// we do not recognize these combinations as "unmanaged"
hasUnmanagedModreqPattern = false;
Interlocked.CompareExchange(ref _lazyConstraintsUseSiteErrorInfo, new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this), CSDiagnosticInfo.EmptyErrorInfo);
}
_lazyHasIsUnmanagedConstraint = hasUnmanagedModreqPattern.ToThreeState();
ImmutableInterlocked.InterlockedInitialize(ref _lazyDeclaredConstraintTypes, declaredConstraintTypes);
}
return(_lazyDeclaredConstraintTypes);
}
private static void AppendMethod(StringBuilder result, PEMethodSymbol method, string indent, bool includeTypeName = false)
{
MetadataSignatureHelper.AppendMethodAttributes(result, method.Flags);
result.Append(" ");
AppendSignatureType(result, method.ReturnType, RefKind.None);
result.Append(" ");
if (includeTypeName)
{
result.Append(method.ContainingType);
result.Append("::");
}
result.Append(method.Name);
result.Append("(");
bool hasParameterAttributes = false;
int i = 0;
foreach (PEParameterSymbol parameter in method.Parameters)
{
if (i > 0)
{
result.Append(", ");
}
if (parameter.GetAttributes().Length > 0)
{
hasParameterAttributes = true;
}
if (MetadataSignatureHelper.AppendParameterAttributes(result, parameter.Flags, all: true))
{
result.Append(" ");
}
AppendSignatureType(result, parameter.Type, parameter.RefKind);
result.Append(" ");
result.Append(parameter.Name);
i++;
}
result.Append(") ");
MetadataSignatureHelper.AppendMethodImplAttributes(result, method.ImplementationAttributes);
if (indent != null)
{
result.AppendLine();
if (hasParameterAttributes)
{
result.Append(indent);
result.AppendLine("{");
string memberIndent = indent + " ";
i = 1;
foreach (PEParameterSymbol parameter in method.Parameters)
{
if (parameter.GetAttributes().Length > 0)
{
result.Append(memberIndent);
result.AppendFormat(".param [{0}]", i);
result.AppendLine();
AppendCustomAttributes(result, parameter, indent, inBlock: true);
}
i++;
}
result.Append(indent);
result.AppendLine("}");
}
}
}
private static bool DoModifiersMatch(PEMethodSymbol addMethod, PEMethodSymbol removeMethod)
{
// CONSIDER: unlike for properties, a non-bogus event can have one abstract accessor
// and one sealed accessor. Since the event is not bogus, the abstract accessor cannot
// be overridden separately. Consequently, the type cannot be extended.
return
(addMethod.IsExtern == removeMethod.IsExtern) &&
// (addMethod.IsAbstract == removeMethod.IsAbstract) && // NOTE: Dev10 accepts one abstract accessor (same as for events)
// (addMethod.IsSealed == removeMethod.IsSealed) && // NOTE: Dev10 accepts one sealed accessor (for events, not for properties)
// (addMethod.IsOverride == removeMethod.IsOverride) && // NOTE: Dev10 accepts one override accessor (for events, not for properties)
(addMethod.IsStatic == removeMethod.IsStatic);
}
internal PEEventSymbol(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
EventDefinitionHandle handle,
PEMethodSymbol addMethod,
PEMethodSymbol removeMethod,
MultiDictionary <string, PEFieldSymbol> privateFieldNameToSymbols)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingType != null);
Debug.Assert(!handle.IsNil);
Debug.Assert((object)addMethod != null);
Debug.Assert((object)removeMethod != null);
_addMethod = addMethod;
_removeMethod = removeMethod;
_handle = handle;
_containingType = containingType;
EventAttributes mdFlags = 0;
EntityHandle eventType = default(EntityHandle);
try
{
var module = moduleSymbol.Module;
module.GetEventDefPropsOrThrow(handle, out _name, out mdFlags, out eventType);
}
catch (BadImageFormatException mrEx)
{
if ((object)_name == null)
{
_name = string.Empty;
}
_lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this);
if (eventType.IsNil)
{
_eventType = new UnsupportedMetadataTypeSymbol(mrEx);
}
}
TypeSymbol originalEventType = _eventType;
if ((object)_eventType == null)
{
var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType);
originalEventType = metadataDecoder.GetTypeOfToken(eventType);
const int targetSymbolCustomModifierCount = 0;
_eventType = DynamicTypeDecoder.TransformType(originalEventType, targetSymbolCustomModifierCount, handle, moduleSymbol);
_eventType = TupleTypeDecoder.DecodeTupleTypesIfApplicable(_eventType, handle, moduleSymbol);
}
// IsWindowsRuntimeEvent checks the signatures, so we just have to check the accessors.
bool isWindowsRuntimeEvent = IsWindowsRuntimeEvent;
bool callMethodsDirectly = isWindowsRuntimeEvent
? !DoModifiersMatch(_addMethod, _removeMethod)
: !DoSignaturesMatch(moduleSymbol, originalEventType, _addMethod, _removeMethod);
if (callMethodsDirectly)
{
_flags |= Flags.CallMethodsDirectly;
}
else
{
_addMethod.SetAssociatedEvent(this, MethodKind.EventAdd);
_removeMethod.SetAssociatedEvent(this, MethodKind.EventRemove);
PEFieldSymbol associatedField = GetAssociatedField(privateFieldNameToSymbols, isWindowsRuntimeEvent);
if ((object)associatedField != null)
{
_associatedFieldOpt = associatedField;
associatedField.SetAssociatedEvent(this);
}
}
if ((mdFlags & EventAttributes.SpecialName) != 0)
{
_flags |= Flags.IsSpecialName;
}
if ((mdFlags & EventAttributes.RTSpecialName) != 0)
{
_flags |= Flags.IsRuntimeSpecialName;
}
}
internal PEEventSymbol(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
EventDefinitionHandle handle,
PEMethodSymbol addMethod,
PEMethodSymbol removeMethod,
MultiDictionary<string, PEFieldSymbol> privateFieldNameToSymbols)
{
Debug.Assert((object)moduleSymbol != null);
Debug.Assert((object)containingType != null);
Debug.Assert(!handle.IsNil);
Debug.Assert((object)addMethod != null);
Debug.Assert((object)removeMethod != null);
_addMethod = addMethod;
_removeMethod = removeMethod;
_handle = handle;
_containingType = containingType;
EventAttributes mdFlags = 0;
EntityHandle eventType = default(EntityHandle);
try
{
var module = moduleSymbol.Module;
module.GetEventDefPropsOrThrow(handle, out _name, out mdFlags, out eventType);
}
catch (BadImageFormatException mrEx)
{
if ((object)_name == null)
{
_name = string.Empty;
}
_lazyUseSiteDiagnostic = new CSDiagnosticInfo(ErrorCode.ERR_BindToBogus, this);
if (eventType.IsNil)
{
_eventType = new UnsupportedMetadataTypeSymbol(mrEx);
}
}
TypeSymbol originalEventType = _eventType;
if ((object)_eventType == null)
{
var metadataDecoder = new MetadataDecoder(moduleSymbol, containingType);
originalEventType = metadataDecoder.GetTypeOfToken(eventType);
const int targetSymbolCustomModifierCount = 0;
_eventType = DynamicTypeDecoder.TransformType(originalEventType, targetSymbolCustomModifierCount, handle, moduleSymbol);
_eventType = TupleTypeDecoder.DecodeTupleTypesIfApplicable(_eventType, handle, moduleSymbol);
}
// IsWindowsRuntimeEvent checks the signatures, so we just have to check the accessors.
bool isWindowsRuntimeEvent = IsWindowsRuntimeEvent;
bool callMethodsDirectly = isWindowsRuntimeEvent
? !DoModifiersMatch(_addMethod, _removeMethod)
: !DoSignaturesMatch(moduleSymbol, originalEventType, _addMethod, _removeMethod);
if (callMethodsDirectly)
{
_flags |= Flags.CallMethodsDirectly;
}
else
{
_addMethod.SetAssociatedEvent(this, MethodKind.EventAdd);
_removeMethod.SetAssociatedEvent(this, MethodKind.EventRemove);
PEFieldSymbol associatedField = GetAssociatedField(privateFieldNameToSymbols, isWindowsRuntimeEvent);
if ((object)associatedField != null)
{
_associatedFieldOpt = associatedField;
associatedField.SetAssociatedEvent(this);
}
}
if ((mdFlags & EventAttributes.SpecialName) != 0)
{
_flags |= Flags.IsSpecialName;
}
if ((mdFlags & EventAttributes.RTSpecialName) != 0)
{
_flags |= Flags.IsRuntimeSpecialName;
}
}
private PEPropertySymbol(
PEModuleSymbol moduleSymbol,
PENamedTypeSymbol containingType,
PropertyDefinitionHandle handle,
PEMethodSymbol getMethod,
PEMethodSymbol setMethod,
int countOfCustomModifiers,
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];
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;
#if XSHARP
_propertyType = DynamicTypeDecoder.TransformType(originalPropertyType, countOfCustomModifiers, handle.IsNil ? (EntityHandle)getMethod.Handle : handle, moduleSymbol, _refKind);
#else
_propertyType = DynamicTypeDecoder.TransformType(originalPropertyType, countOfCustomModifiers, handle, moduleSymbol, _refKind);
#endif
// 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 XSHARP
if (handle.IsNil)
{
callMethodsDirectly = true;
}
#endif
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;
}
}