protected static void CopyEventCustomModifiers(EventSymbol eventWithCustomModifiers, ref TypeSymbolWithAnnotations type, AssemblySymbol containingAssembly)
{
Debug.Assert((object)eventWithCustomModifiers != null);
TypeSymbol overriddenEventType = eventWithCustomModifiers.Type.TypeSymbol;
// We do an extra check before copying the type to handle the case where the overriding
// event (incorrectly) has a different type than the overridden event. In such cases,
// we want to retain the original (incorrect) type to avoid hiding the type given in source.
if (type.TypeSymbol.Equals(overriddenEventType, TypeCompareKind.IgnoreCustomModifiersAndArraySizesAndLowerBounds | TypeCompareKind.IgnoreNullableModifiersForReferenceTypes | TypeCompareKind.IgnoreDynamic))
{
type = type.WithTypeAndModifiers(CustomModifierUtils.CopyTypeCustomModifiers(overriddenEventType, type.TypeSymbol, containingAssembly),
eventWithCustomModifiers.Type.CustomModifiers);
}
}
protected override void MethodChecks(DiagnosticBag diagnostics)
{
// These values may not be final, but we need to have something set here in the
// event that we need to find the overridden accessor.
_lazyParameters = ComputeParameters(diagnostics);
_lazyReturnType = ComputeReturnType(diagnostics);
_lazyRefCustomModifiers = ImmutableArray <CustomModifier> .Empty;
if (_explicitInterfaceImplementations.Length > 0)
{
Debug.Assert(_explicitInterfaceImplementations.Length == 1);
MethodSymbol implementedMethod = _explicitInterfaceImplementations[0];
CustomModifierUtils.CopyMethodCustomModifiers(implementedMethod, this, out _lazyReturnType,
out _lazyRefCustomModifiers,
out _lazyParameters, alsoCopyParamsModifier: false);
}
else if (this.IsOverride)
{
// This will cause another call to SourceMethodSymbol.LazyMethodChecks,
// but that method already handles reentrancy for exactly this case.
MethodSymbol overriddenMethod = this.OverriddenMethod;
if ((object)overriddenMethod != null)
{
CustomModifierUtils.CopyMethodCustomModifiers(overriddenMethod, this, out _lazyReturnType,
out _lazyRefCustomModifiers,
out _lazyParameters, alsoCopyParamsModifier: true);
}
}
else if (_lazyReturnType.SpecialType != SpecialType.System_Void)
{
PropertySymbol associatedProperty = _property;
var type = associatedProperty.Type;
_lazyReturnType = _lazyReturnType.WithTypeAndModifiers(
CustomModifierUtils.CopyTypeCustomModifiers(type.TypeSymbol, _lazyReturnType.TypeSymbol, this.ContainingAssembly),
type.CustomModifiers);
_lazyRefCustomModifiers = associatedProperty.RefCustomModifiers;
}
}
internal SourceParameterSymbol WithCustomModifiersAndParamsCore(TypeSymbol newType, ImmutableArray <CustomModifier> newCustomModifiers, ImmutableArray <CustomModifier> newRefCustomModifiers, bool newIsParams)
{
newType = CustomModifierUtils.CopyTypeCustomModifiers(newType, this.Type.TypeSymbol, this.ContainingAssembly);
TypeSymbolWithAnnotations newTypeWithModifiers = this.Type.WithTypeAndModifiers(newType, newCustomModifiers);
if (newRefCustomModifiers.IsEmpty)
{
return(new SourceComplexParameterSymbol(
this.ContainingSymbol,
this.Ordinal,
newTypeWithModifiers,
_refKind,
_name,
_locations,
this.SyntaxReference,
this.ExplicitDefaultConstantValue,
newIsParams,
this.IsExtensionMethodThis));
}
// Local functions should never have custom modifiers
Debug.Assert(!(ContainingSymbol is LocalFunctionSymbol));
return(new SourceComplexParameterSymbolWithCustomModifiersPrecedingByRef(
this.ContainingSymbol,
this.Ordinal,
newTypeWithModifiers,
_refKind,
newRefCustomModifiers,
_name,
_locations,
this.SyntaxReference,
this.ExplicitDefaultConstantValue,
newIsParams,
this.IsExtensionMethodThis));
}
