internal SourceMemberFieldSymbol(
SourceMemberContainerTypeSymbol containingType,
VariableDeclaratorSyntax declarator,
DeclarationModifiers modifiers,
bool modifierErrors,
DiagnosticBag diagnostics)
: base(containingType, declarator.Identifier.ValueText, declarator.GetReference(), declarator.Identifier.GetLocation())
{
this.modifiers = modifiers;
this.CheckAccessibility(diagnostics);
var location = Location;
if (modifierErrors)
{
// skip the following checks
}
else if (containingType.IsSealed && (DeclaredAccessibility == Accessibility.Protected || DeclaredAccessibility == Accessibility.ProtectedOrInternal))
{
diagnostics.Add(AccessCheck.GetProtectedMemberInSealedTypeError(containingType), location, this);
}
else if (IsVolatile && IsReadOnly)
{
diagnostics.Add(ErrorCode.ERR_VolatileAndReadonly, location, this);
}
else if (containingType.IsStatic && !IsStatic)
{
diagnostics.Add(ErrorCode.ERR_InstanceMemberInStaticClass, location, this);
}
// TODO: Consider checking presence of core type System.Runtime.CompilerServices.IsVolatile
// if there is a volatile modifier. Perhaps an appropriate error should be reported if the
// type isn’t available.
}
internal SynthesizedInteractiveInitializerMethod(SourceMemberContainerTypeSymbol containingType, DiagnosticBag diagnostics)
{
Debug.Assert(containingType.IsScriptClass);
_containingType = containingType;
CalculateReturnType(containingType.DeclaringCompilation, diagnostics, out _resultType, out _returnType);
}
public static SourceConstructorSymbol CreatePrimaryConstructorSymbol(
SourceMemberContainerTypeSymbol containingType,
ParameterListSyntax syntax,
DiagnosticBag diagnostics)
{
return new SourceConstructorSymbol(containingType, syntax.GetLocation(), syntax, diagnostics);
}
private SourceConstructorSymbol(
SourceMemberContainerTypeSymbol containingType,
Location location,
ConstructorDeclarationSyntax syntax,
MethodKind methodKind,
DiagnosticBag diagnostics) :
base(containingType, syntax.GetReference(), syntax.Body.GetReferenceOrNull(), ImmutableArray.Create(location))
{
bool modifierErrors;
var declarationModifiers = this.MakeModifiers(syntax.Modifiers, methodKind, location, diagnostics, out modifierErrors);
this.flags = MakeFlags(methodKind, declarationModifiers, returnsVoid: true, isExtensionMethod: false);
var bodyOpt = syntax.Body;
if (bodyOpt != null)
{
if (IsExtern)
{
diagnostics.Add(ErrorCode.ERR_ExternHasBody, location, this);
}
}
var info = ModifierUtils.CheckAccessibility(this.DeclarationModifiers);
if (info != null)
{
diagnostics.Add(info, location);
}
if (!modifierErrors)
{
this.CheckModifiers(methodKind, location, diagnostics);
}
}
internal static ImmutableArray<BoundInitializer> BindFieldInitializers(
SourceMemberContainerTypeSymbol containingType,
MethodSymbol scriptCtor,
ImmutableArray<FieldInitializers> initializers,
DiagnosticBag diagnostics,
bool generateDebugInfo,
out ConsList<Imports> firstDebugImports)
{
if (initializers.IsEmpty)
{
firstDebugImports = null;
return ImmutableArray<BoundInitializer>.Empty;
}
CSharpCompilation compilation = containingType.DeclaringCompilation;
ArrayBuilder<BoundInitializer> boundInitializers = ArrayBuilder<BoundInitializer>.GetInstance();
if ((object)scriptCtor == null)
{
BindRegularCSharpFieldInitializers(compilation, initializers, boundInitializers, diagnostics, generateDebugInfo, out firstDebugImports);
}
else
{
BindScriptFieldInitializers(compilation, scriptCtor, initializers, boundInitializers, diagnostics, generateDebugInfo, out firstDebugImports);
}
return boundInitializers.ToImmutableAndFree();
}
internal static void BindFieldInitializers(
SourceMemberContainerTypeSymbol typeSymbol,
MethodSymbol scriptCtor,
ImmutableArray<FieldInitializers> fieldInitializers,
bool generateDebugInfo,
DiagnosticBag diagnostics,
ref ProcessedFieldInitializers processedInitializers) //by ref so that we can store the results of lowering
{
DiagnosticBag diagsForInstanceInitializers = DiagnosticBag.GetInstance();
try
{
ConsList<Imports> firstDebugImports;
processedInitializers.BoundInitializers = BindFieldInitializers(typeSymbol, scriptCtor, fieldInitializers,
diagsForInstanceInitializers, generateDebugInfo, out firstDebugImports);
processedInitializers.HasErrors = diagsForInstanceInitializers.HasAnyErrors();
processedInitializers.FirstDebugImports = firstDebugImports;
}
finally
{
diagnostics.AddRange(diagsForInstanceInitializers);
diagsForInstanceInitializers.Free();
}
}
public static SourceConstructorSymbol CreateConstructorSymbol(
SourceMemberContainerTypeSymbol containingType,
ConstructorDeclarationSyntax syntax,
DiagnosticBag diagnostics)
{
var methodKind = syntax.Modifiers.Any(SyntaxKind.StaticKeyword) ? MethodKind.StaticConstructor : MethodKind.Constructor;
return new SourceConstructorSymbol(containingType, syntax.Identifier.GetLocation(), syntax, methodKind, diagnostics);
}
protected SourceEnumConstantSymbol(SourceMemberContainerTypeSymbol containingEnum, EnumMemberDeclarationSyntax syntax, DiagnosticBag diagnostics)
: base(containingEnum, syntax.Identifier.ValueText, syntax.GetReference(), syntax.Identifier.GetLocation())
{
if (this.Name == WellKnownMemberNames.EnumBackingFieldName)
{
diagnostics.Add(ErrorCode.ERR_ReservedEnumerator, this.Location, WellKnownMemberNames.EnumBackingFieldName);
}
}
public static SourceEnumConstantSymbol CreateExplicitValuedConstant(
SourceMemberContainerTypeSymbol containingEnum,
EnumMemberDeclarationSyntax syntax,
DiagnosticBag diagnostics)
{
var initializer = syntax.EqualsValue;
Debug.Assert(initializer != null);
return new ExplicitValuedEnumConstantSymbol(containingEnum, syntax, initializer, diagnostics);
}
internal SourceMemberFieldSymbol(
SourceMemberContainerTypeSymbol containingType,
DeclarationModifiers modifiers,
string name,
SyntaxReference syntax,
Location location)
: base(containingType, name, syntax, location)
{
_modifiers = modifiers;
}
private SourceConstructorSymbol(
SourceMemberContainerTypeSymbol containingType,
Location location,
ParameterListSyntax syntax,
DiagnosticBag diagnostics) :
base(containingType, syntax.GetReference(), GetPrimaryConstructorBlockSyntaxReferenceOrNull(syntax), ImmutableArray.Create(location))
{
var declarationModifiers = (containingType.IsAbstract ? DeclarationModifiers.Protected : DeclarationModifiers.Public) | DeclarationModifiers.PrimaryCtor;
this.flags = MakeFlags(MethodKind.Constructor, declarationModifiers, returnsVoid: true, isExtensionMethod: false);
this.CheckModifiers(MethodKind.Constructor, location, diagnostics);
}
protected SourceDelegateMethodSymbol(
SourceMemberContainerTypeSymbol delegateType,
TypeSymbol returnType,
DelegateDeclarationSyntax syntax,
MethodKind methodKind,
DeclarationModifiers declarationModifiers)
: base(delegateType, syntax.GetReference(), bodySyntaxReferenceOpt: null, location: syntax.Identifier.GetLocation())
{
_returnType = returnType;
this.MakeFlags(methodKind, declarationModifiers, _returnType.SpecialType == SpecialType.System_Void, isExtensionMethod: false);
}
public static SourceUserDefinedOperatorSymbol CreateUserDefinedOperatorSymbol(
SourceMemberContainerTypeSymbol containingType,
OperatorDeclarationSyntax syntax,
DiagnosticBag diagnostics)
{
var location = syntax.OperatorToken.GetLocation();
string name = OperatorFacts.OperatorNameFromDeclaration(syntax);
return new SourceUserDefinedOperatorSymbol(
containingType, name, location, syntax, diagnostics);
}
internal GlobalExpressionVariable(
SourceMemberContainerTypeSymbol containingType,
DeclarationModifiers modifiers,
TypeSyntax typeSyntax,
string name,
SyntaxReference syntax,
Location location)
: base(containingType, modifiers, name, syntax, location)
{
Debug.Assert(DeclaredAccessibility == Accessibility.Private);
_typeSyntax = typeSyntax.GetReference();
}
protected SourceFieldSymbol(SourceMemberContainerTypeSymbol containingType, string name, SyntaxReference syntax, Location location)
{
Debug.Assert((object)containingType != null);
Debug.Assert(name != null);
Debug.Assert(syntax != null);
Debug.Assert(location != null);
this.containingType = containingType;
this.name = name;
this.syntaxReference = syntax;
this.location = location;
}
internal SourceFixedFieldSymbol(
SourceMemberContainerTypeSymbol containingType,
VariableDeclaratorSyntax declarator,
DeclarationModifiers modifiers,
bool modifierErrors,
DiagnosticBag diagnostics)
: base(containingType, declarator, modifiers, modifierErrors, diagnostics)
{
// Checked in parser: a fixed field declaration requires a length in square brackets
Debug.Assert(this.IsFixed);
}
internal SynthesizedInteractiveInitializerMethod(SourceMemberContainerTypeSymbol containingType, DiagnosticBag diagnostics)
{
Debug.Assert(containingType.IsScriptClass);
_containingType = containingType;
var compilation = containingType.DeclaringCompilation;
var submissionReturnType = compilation.SubmissionReturnType;
_resultType = (submissionReturnType == null) ?
null :
compilation.GetTypeByReflectionType(submissionReturnType, diagnostics);
}
public static SourceUserDefinedConversionSymbol CreateUserDefinedConversionSymbol(
SourceMemberContainerTypeSymbol containingType,
ConversionOperatorDeclarationSyntax syntax,
DiagnosticBag diagnostics)
{
// Dev11 includes the explicit/implicit keyword, but we don't have a good way to include
// Narrowing/Widening in VB and we want the languages to be consistent.
var location = syntax.Type.Location;
string name = syntax.ImplicitOrExplicitKeyword.IsKind(SyntaxKind.ImplicitKeyword) ?
WellKnownMemberNames.ImplicitConversionName :
WellKnownMemberNames.ExplicitConversionName;
return new SourceUserDefinedConversionSymbol(
containingType, name, location, syntax, diagnostics);
}
// NOTE: no need to call WithUnsafeRegionIfNecessary, since the signature
// is bound lazily using binders from a BinderFactory (which will already include an
// UnsafeBinder, if necessary).
private SourceUserDefinedOperatorSymbol(
SourceMemberContainerTypeSymbol containingType,
string name,
Location location,
OperatorDeclarationSyntax syntax,
DiagnosticBag diagnostics) :
base(
MethodKind.UserDefinedOperator,
name,
containingType,
location,
syntax.GetReference(),
syntax.Body.GetReferenceOrNull(),
syntax.Modifiers,
diagnostics)
{
}
internal static GlobalExpressionVariable Create(
SourceMemberContainerTypeSymbol containingType,
DeclarationModifiers modifiers,
TypeSyntax typeSyntax,
string name,
SyntaxNode syntax,
Location location,
FieldSymbol containingFieldOpt,
SyntaxNode nodeToBind)
{
Debug.Assert(nodeToBind.Kind() == SyntaxKind.VariableDeclarator || nodeToBind is ExpressionSyntax);
var syntaxReference = syntax.GetReference();
return typeSyntax.IsVar
? new InferrableGlobalExpressionVariable(containingType, modifiers, typeSyntax, name, syntaxReference, location, containingFieldOpt, nodeToBind)
: new GlobalExpressionVariable(containingType, modifiers, typeSyntax, name, syntaxReference, location);
}
public static SourceEnumConstantSymbol CreateImplicitValuedConstant(
SourceMemberContainerTypeSymbol containingEnum,
EnumMemberDeclarationSyntax syntax,
SourceEnumConstantSymbol otherConstant,
int otherConstantOffset,
DiagnosticBag diagnostics)
{
if ((object)otherConstant == null)
{
Debug.Assert(otherConstantOffset == 0);
return new ZeroValuedEnumConstantSymbol(containingEnum, syntax, diagnostics);
}
else
{
Debug.Assert(otherConstantOffset > 0);
return new ImplicitValuedEnumConstantSymbol(containingEnum, syntax, otherConstant, (uint)otherConstantOffset, diagnostics);
}
}
internal SourceMemberFieldSymbol(
SourceMemberContainerTypeSymbol containingType,
VariableDeclaratorSyntax declarator,
DeclarationModifiers modifiers,
bool modifierErrors,
DiagnosticBag diagnostics)
: base(containingType, declarator.Identifier.ValueText, declarator.GetReference(), declarator.Identifier.GetLocation())
{
_modifiers = modifiers;
_hasInitializer = declarator.Initializer != null;
this.CheckAccessibility(diagnostics);
if (!modifierErrors)
{
this.ReportModifiersDiagnostics(diagnostics);
}
}
// NOTE: no need to call WithUnsafeRegionIfNecessary, since the signature
// is bound lazily using binders from a BinderFactory (which will already include an
// UnsafeBinder, if necessary).
private SourceUserDefinedConversionSymbol(
SourceMemberContainerTypeSymbol containingType,
string name,
Location location,
ConversionOperatorDeclarationSyntax syntax,
DiagnosticBag diagnostics,
bool isExpressionBodied) :
base(
MethodKind.Conversion,
name,
containingType,
location,
syntax.GetReference(),
syntax.Body?.GetReference() ?? syntax.ExpressionBody?.GetReference(),
syntax.Modifiers,
diagnostics,
isExpressionBodied)
{
}
// TODO: CLSCompliantAttribute
internal SourceEventSymbol(
SourceMemberContainerTypeSymbol containingType,
CSharpSyntaxNode syntax,
SyntaxTokenList modifiers,
ExplicitInterfaceSpecifierSyntax interfaceSpecifierSyntaxOpt,
SyntaxToken nameTokenSyntax,
DiagnosticBag diagnostics)
{
_location = nameTokenSyntax.GetLocation();
this.containingType = containingType;
_syntaxRef = syntax.GetReference();
var isExplicitInterfaceImplementation = interfaceSpecifierSyntaxOpt != null;
bool modifierErrors;
_modifiers = MakeModifiers(modifiers, isExplicitInterfaceImplementation, _location, diagnostics, out modifierErrors);
this.CheckAccessibility(_location, diagnostics);
}
internal SourceDestructorSymbol(
SourceMemberContainerTypeSymbol containingType,
DestructorDeclarationSyntax syntax,
DiagnosticBag diagnostics) :
base(containingType, syntax.GetReference(), syntax.Body?.GetReference() ?? syntax.ExpressionBody?.GetReference() , syntax.Identifier.GetLocation())
{
const MethodKind methodKind = MethodKind.Destructor;
Location location = this.Locations[0];
bool modifierErrors;
var declarationModifiers = MakeModifiers(syntax.Modifiers, location, diagnostics, out modifierErrors);
this.MakeFlags(methodKind, declarationModifiers, returnsVoid: true, isExtensionMethod: false);
bool hasBlockBody = syntax.Body != null;
_isExpressionBodied = !hasBlockBody && syntax.ExpressionBody != null;
if (hasBlockBody || _isExpressionBodied)
{
if (IsExtern)
{
diagnostics.Add(ErrorCode.ERR_ExternHasBody, location, this);
}
}
if (!modifierErrors && bodySyntaxReferenceOpt == null && !IsExtern)
{
diagnostics.Add(ErrorCode.ERR_ConcreteMissingBody, location, this);
}
Debug.Assert(syntax.ParameterList.Parameters.Count == 0);
if (containingType.IsStatic)
{
diagnostics.Add(ErrorCode.ERR_DestructorInStaticClass, location, this);
}
else if (!containingType.IsReferenceType)
{
diagnostics.Add(ErrorCode.ERR_OnlyClassesCanContainDestructors, location, this);
}
}
private SourceConstructorSymbol(
SourceMemberContainerTypeSymbol containingType,
Location location,
ConstructorDeclarationSyntax syntax,
MethodKind methodKind,
DiagnosticBag diagnostics) :
base(containingType, syntax.GetReference(), syntax.Body?.GetReference() ?? syntax.ExpressionBody?.GetReference(), ImmutableArray.Create(location))
{
bool modifierErrors;
var declarationModifiers = this.MakeModifiers(syntax.Modifiers, methodKind, location, diagnostics, out modifierErrors);
this.MakeFlags(methodKind, declarationModifiers, returnsVoid: true, isExtensionMethod: false);
bool hasBlockBody = syntax.Body != null;
_isExpressionBodied = !hasBlockBody && syntax.ExpressionBody != null;
if (IsExtern)
{
if (methodKind == MethodKind.Constructor && syntax.Initializer != null)
{
diagnostics.Add(ErrorCode.ERR_ExternHasConstructorInitializer, location, this);
}
if (hasBlockBody || _isExpressionBodied)
{
diagnostics.Add(ErrorCode.ERR_ExternHasBody, location, this);
}
}
var info = ModifierUtils.CheckAccessibility(this.DeclarationModifiers);
if (info != null)
{
diagnostics.Add(info, location);
}
if (!modifierErrors)
{
this.CheckModifiers(methodKind, location, diagnostics);
}
}
internal static void BindFieldInitializers(
SourceMemberContainerTypeSymbol typeSymbol,
MethodSymbol scriptCtor,
ImmutableArray<ImmutableArray<FieldOrPropertyInitializer>> fieldInitializers,
DiagnosticBag diagnostics,
ref ProcessedFieldInitializers processedInitializers) //by ref so that we can store the results of lowering
{
DiagnosticBag diagsForInstanceInitializers = DiagnosticBag.GetInstance();
try
{
ImportChain firstImportChain;
processedInitializers.BoundInitializers = BindFieldInitializers(typeSymbol, scriptCtor, fieldInitializers,
diagsForInstanceInitializers, out firstImportChain);
processedInitializers.HasErrors = diagsForInstanceInitializers.HasAnyErrors();
processedInitializers.FirstImportChain = firstImportChain;
}
finally
{
diagnostics.AddRange(diagsForInstanceInitializers);
diagsForInstanceInitializers.Free();
}
}
public SynthesizedRecordToString(SourceMemberContainerTypeSymbol containingType, MethodSymbol printMethod, int memberOffset, BindingDiagnosticBag diagnostics)
: base(containingType, WellKnownMemberNames.ObjectToString, memberOffset, diagnostics)
{
Debug.Assert(printMethod is object);
_printMethod = printMethod;
}
internal SourceCustomEventSymbol(SourceMemberContainerTypeSymbol containingType, Binder binder, EventDeclarationSyntax syntax, DiagnosticBag diagnostics) :
base(containingType, syntax, syntax.Modifiers, isFieldLike: false,
interfaceSpecifierSyntaxOpt: syntax.ExplicitInterfaceSpecifier,
nameTokenSyntax: syntax.Identifier, diagnostics: diagnostics)
{
ExplicitInterfaceSpecifierSyntax interfaceSpecifier = syntax.ExplicitInterfaceSpecifier;
SyntaxToken nameToken = syntax.Identifier;
bool isExplicitInterfaceImplementation = interfaceSpecifier != null;
string aliasQualifierOpt;
_name = ExplicitInterfaceHelpers.GetMemberNameAndInterfaceSymbol(binder, interfaceSpecifier, nameToken.ValueText, diagnostics, out _explicitInterfaceType, out aliasQualifierOpt);
_type = BindEventType(binder, syntax.Type, diagnostics);
var explicitlyImplementedEvent = this.FindExplicitlyImplementedEvent(_explicitInterfaceType, nameToken.ValueText, interfaceSpecifier, diagnostics);
this.FindExplicitlyImplementedMemberVerification(explicitlyImplementedEvent, diagnostics);
// The runtime will not treat the accessors of this event as overrides or implementations
// of those of another event unless both the signatures and the custom modifiers match.
// Hence, in the case of overrides and *explicit* implementations, we need to copy the custom
// modifiers that are in the signatures of the overridden/implemented event accessors.
// (From source, we know that there can only be one overridden/implemented event, so there
// are no conflicts.) This is unnecessary for implicit implementations because, if the custom
// modifiers don't match, we'll insert bridge methods for the accessors (explicit implementations
// that delegate to the implicit implementations) with the correct custom modifiers
// (see SourceMemberContainerTypeSymbol.SynthesizeInterfaceMemberImplementation).
// Note: we're checking if the syntax indicates explicit implementation rather,
// than if explicitInterfaceType is null because we don't want to look for an
// overridden event if this is supposed to be an explicit implementation.
if (!isExplicitInterfaceImplementation)
{
// If this event is an override, we may need to copy custom modifiers from
// the overridden event (so that the runtime will recognize it as an override).
// We check for this case here, while we can still modify the parameters and
// return type without losing the appearance of immutability.
if (this.IsOverride)
{
EventSymbol overriddenEvent = this.OverriddenEvent;
if ((object)overriddenEvent != null)
{
CopyEventCustomModifiers(overriddenEvent, ref _type, ContainingAssembly);
}
}
}
else if ((object)explicitlyImplementedEvent != null)
{
CopyEventCustomModifiers(explicitlyImplementedEvent, ref _type, ContainingAssembly);
}
AccessorDeclarationSyntax addSyntax = null;
AccessorDeclarationSyntax removeSyntax = null;
if (syntax.AccessorList != null)
{
foreach (AccessorDeclarationSyntax accessor in syntax.AccessorList.Accessors)
{
bool checkBody = false;
switch (accessor.Kind())
{
case SyntaxKind.AddAccessorDeclaration:
if (addSyntax == null)
{
addSyntax = accessor;
checkBody = true;
}
else
{
diagnostics.Add(ErrorCode.ERR_DuplicateAccessor, accessor.Keyword.GetLocation());
}
break;
case SyntaxKind.RemoveAccessorDeclaration:
if (removeSyntax == null)
{
removeSyntax = accessor;
checkBody = true;
}
else
{
diagnostics.Add(ErrorCode.ERR_DuplicateAccessor, accessor.Keyword.GetLocation());
}
break;
case SyntaxKind.GetAccessorDeclaration:
case SyntaxKind.SetAccessorDeclaration:
diagnostics.Add(ErrorCode.ERR_AddOrRemoveExpected, accessor.Keyword.GetLocation());
break;
case SyntaxKind.UnknownAccessorDeclaration:
// Don't need to handle UnknownAccessorDeclaration. An error will have
// already been produced for it in the parser.
break;
default:
throw ExceptionUtilities.UnexpectedValue(accessor.Kind());
}
if (checkBody && !IsAbstract && accessor.Body == null && accessor.ExpressionBody == null && accessor.SemicolonToken.Kind() == SyntaxKind.SemicolonToken)
{
diagnostics.Add(ErrorCode.ERR_AddRemoveMustHaveBody, accessor.SemicolonToken.GetLocation());
}
}
if (IsAbstract)
{
if (!syntax.AccessorList.OpenBraceToken.IsMissing)
{
diagnostics.Add(ErrorCode.ERR_AbstractEventHasAccessors, syntax.AccessorList.OpenBraceToken.GetLocation(), this);
}
}
else if ((addSyntax == null || removeSyntax == null) && (!syntax.AccessorList.OpenBraceToken.IsMissing || !isExplicitInterfaceImplementation))
{
diagnostics.Add(ErrorCode.ERR_EventNeedsBothAccessors, this.Locations[0], this);
}
}
else if (isExplicitInterfaceImplementation && !IsAbstract)
{
diagnostics.Add(ErrorCode.ERR_ExplicitEventFieldImpl, this.Locations[0]);
}
if (isExplicitInterfaceImplementation && IsAbstract && syntax.AccessorList == null)
{
Debug.Assert(containingType.IsInterface);
Binder.CheckFeatureAvailability(syntax, MessageID.IDS_DefaultInterfaceImplementation, diagnostics, this.Locations[0]);
if (!ContainingAssembly.RuntimeSupportsDefaultInterfaceImplementation)
{
diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation, this.Locations[0]);
}
_addMethod = new SynthesizedEventAccessorSymbol(this, isAdder: true, explicitlyImplementedEvent, aliasQualifierOpt);
_removeMethod = new SynthesizedEventAccessorSymbol(this, isAdder: false, explicitlyImplementedEvent, aliasQualifierOpt);
}
else
{
_addMethod = CreateAccessorSymbol(addSyntax, explicitlyImplementedEvent, aliasQualifierOpt, diagnostics);
_removeMethod = CreateAccessorSymbol(removeSyntax, explicitlyImplementedEvent, aliasQualifierOpt, diagnostics);
}
_explicitInterfaceImplementations =
(object)explicitlyImplementedEvent == null ?
ImmutableArray <EventSymbol> .Empty :
ImmutableArray.Create <EventSymbol>(explicitlyImplementedEvent);
}
internal SourceCustomEventSymbol(SourceMemberContainerTypeSymbol containingType, Binder binder, EventDeclarationSyntax syntax, DiagnosticBag diagnostics) :
base(containingType, syntax, syntax.Modifiers, syntax.ExplicitInterfaceSpecifier, syntax.Identifier, diagnostics)
{
ExplicitInterfaceSpecifierSyntax interfaceSpecifier = syntax.ExplicitInterfaceSpecifier;
SyntaxToken nameToken = syntax.Identifier;
bool isExplicitInterfaceImplementation = interfaceSpecifier != null;
string aliasQualifierOpt;
_name = ExplicitInterfaceHelpers.GetMemberNameAndInterfaceSymbol(binder, interfaceSpecifier, nameToken.ValueText, diagnostics, out _explicitInterfaceType, out aliasQualifierOpt);
_type = BindEventType(binder, syntax.Type, diagnostics);
var explicitlyImplementedEvent = this.FindExplicitlyImplementedEvent(_explicitInterfaceType, nameToken.ValueText, interfaceSpecifier, diagnostics);
this.FindExplicitlyImplementedMemberVerification(explicitlyImplementedEvent, diagnostics);
// The runtime will not treat the accessors of this event as overrides or implementations
// of those of another event unless both the signatures and the custom modifiers match.
// Hence, in the case of overrides and *explicit* implementations, we need to copy the custom
// modifiers that are in the signatures of the overridden/implemented event accessors.
// (From source, we know that there can only be one overridden/implemented event, so there
// are no conflicts.) This is unnecessary for implicit implementations because, if the custom
// modifiers don't match, we'll insert bridge methods for the accessors (explicit implementations
// that delegate to the implicit implementations) with the correct custom modifiers
// (see SourceMemberContainerTypeSymbol.SynthesizeInterfaceMemberImplementation).
// Note: we're checking if the syntax indicates explicit implementation rather,
// than if explicitInterfaceType is null because we don't want to look for an
// overridden event if this is supposed to be an explicit implementation.
if (!isExplicitInterfaceImplementation)
{
// If this event is an override, we may need to copy custom modifiers from
// the overridden event (so that the runtime will recognize it as an override).
// We check for this case here, while we can still modify the parameters and
// return type without losing the appearance of immutability.
if (this.IsOverride)
{
EventSymbol overriddenEvent = this.OverriddenEvent;
if ((object)overriddenEvent != null)
{
CopyEventCustomModifiers(overriddenEvent, ref _type, ContainingAssembly, nonNullTypesContext: this);
}
}
}
else if ((object)explicitlyImplementedEvent != null)
{
CopyEventCustomModifiers(explicitlyImplementedEvent, ref _type, ContainingAssembly, nonNullTypesContext: this);
}
AccessorDeclarationSyntax addSyntax = null;
AccessorDeclarationSyntax removeSyntax = null;
foreach (AccessorDeclarationSyntax accessor in syntax.AccessorList.Accessors)
{
switch (accessor.Kind())
{
case SyntaxKind.AddAccessorDeclaration:
if (addSyntax == null)
{
addSyntax = accessor;
}
else
{
diagnostics.Add(ErrorCode.ERR_DuplicateAccessor, accessor.Keyword.GetLocation());
}
break;
case SyntaxKind.RemoveAccessorDeclaration:
if (removeSyntax == null)
{
removeSyntax = accessor;
}
else
{
diagnostics.Add(ErrorCode.ERR_DuplicateAccessor, accessor.Keyword.GetLocation());
}
break;
case SyntaxKind.GetAccessorDeclaration:
case SyntaxKind.SetAccessorDeclaration:
diagnostics.Add(ErrorCode.ERR_AddOrRemoveExpected, accessor.Keyword.GetLocation());
break;
case SyntaxKind.UnknownAccessorDeclaration:
// Don't need to handle UnknownAccessorDeclaration. An error will have
// already been produced for it in the parser.
break;
default:
throw ExceptionUtilities.UnexpectedValue(accessor.Kind());
}
}
_addMethod = CreateAccessorSymbol(addSyntax, explicitlyImplementedEvent, aliasQualifierOpt, diagnostics);
_removeMethod = CreateAccessorSymbol(removeSyntax, explicitlyImplementedEvent, aliasQualifierOpt, diagnostics);
if (containingType.IsInterfaceType())
{
if (addSyntax == null && removeSyntax == null) //NOTE: AND - different error code produced if one is present
{
// CONSIDER: we're matching dev10, but it would probably be more helpful to give
// an error like ERR_EventPropertyInInterface.
diagnostics.Add(ErrorCode.ERR_EventNeedsBothAccessors, this.Locations[0], this);
}
}
else
{
if (addSyntax == null || removeSyntax == null)
{
diagnostics.Add(ErrorCode.ERR_EventNeedsBothAccessors, this.Locations[0], this);
}
}
_explicitInterfaceImplementations =
(object)explicitlyImplementedEvent == null ?
ImmutableArray <EventSymbol> .Empty :
ImmutableArray.Create <EventSymbol>(explicitlyImplementedEvent);
}
internal static SourcePropertySymbol Create(SourceMemberContainerTypeSymbol containingType, Binder bodyBinder, IndexerDeclarationSyntax syntax, DiagnosticBag diagnostics)
{
var location = syntax.ThisKeyword.GetLocation();
return new SourcePropertySymbol(containingType, bodyBinder, syntax, DefaultIndexerName, location, diagnostics);
}
protected SourceFieldSymbol(SourceMemberContainerTypeSymbol containingType)
{
Debug.Assert((object)containingType != null);
this.containingType = containingType;
}
internal static SourcePropertySymbol Create(SourceMemberContainerTypeSymbol containingType, Binder bodyBinder, IndexerDeclarationSyntax syntax, BindingDiagnosticBag diagnostics)
{
var location = syntax.ThisKeyword.GetLocation();
return(Create(containingType, bodyBinder, syntax, DefaultIndexerName, location, diagnostics));
}
internal static void AddDelegateMembers(
SourceMemberContainerTypeSymbol delegateType,
ArrayBuilder <Symbol> symbols,
DelegateDeclarationSyntax syntax,
DiagnosticBag diagnostics)
{
Binder binder = delegateType.GetBinder(syntax.ParameterList);
RefKind refKind;
TypeSyntax returnTypeSyntax = syntax.ReturnType.SkipRef(out refKind);
TypeSymbol returnType = binder.BindType(returnTypeSyntax, diagnostics);
// reuse types to avoid reporting duplicate errors if missing:
var voidType = binder.GetSpecialType(SpecialType.System_Void, diagnostics, syntax);
var objectType = binder.GetSpecialType(SpecialType.System_Object, diagnostics, syntax);
var intPtrType = binder.GetSpecialType(SpecialType.System_IntPtr, diagnostics, syntax);
if (returnType.IsRestrictedType())
{
// Method or delegate cannot return type '{0}'
diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, returnTypeSyntax.Location, returnType);
}
// A delegate has the following members: (see CLI spec 13.6)
// (1) a method named Invoke with the specified signature
var invoke = new InvokeMethod(delegateType, refKind, returnType, syntax, binder, diagnostics);
invoke.CheckDelegateVarianceSafety(diagnostics);
symbols.Add(invoke);
// (2) a constructor with argument types (object, System.IntPtr)
symbols.Add(new Constructor(delegateType, voidType, objectType, intPtrType, syntax));
if (binder.Compilation.GetSpecialType(SpecialType.System_IAsyncResult).TypeKind != TypeKind.Error &&
binder.Compilation.GetSpecialType(SpecialType.System_AsyncCallback).TypeKind != TypeKind.Error &&
// WinRT delegates don't have Begin/EndInvoke methods
!delegateType.IsCompilationOutputWinMdObj())
{
var iAsyncResultType = binder.GetSpecialType(SpecialType.System_IAsyncResult, diagnostics, syntax);
var asyncCallbackType = binder.GetSpecialType(SpecialType.System_AsyncCallback, diagnostics, syntax);
// (3) BeginInvoke
symbols.Add(new BeginInvokeMethod(invoke, iAsyncResultType, objectType, asyncCallbackType, syntax));
// and (4) EndInvoke methods
symbols.Add(new EndInvokeMethod(invoke, iAsyncResultType, syntax));
}
if (delegateType.DeclaredAccessibility <= Accessibility.Private)
{
return;
}
HashSet <DiagnosticInfo> useSiteDiagnostics = null;
if (!delegateType.IsNoMoreVisibleThan(invoke.ReturnType, ref useSiteDiagnostics))
{
// Inconsistent accessibility: return type '{1}' is less accessible than delegate '{0}'
diagnostics.Add(ErrorCode.ERR_BadVisDelegateReturn, delegateType.Locations[0], delegateType, invoke.ReturnType);
}
foreach (var parameter in invoke.Parameters)
{
if (!parameter.Type.IsAtLeastAsVisibleAs(delegateType, ref useSiteDiagnostics))
{
// Inconsistent accessibility: parameter type '{1}' is less accessible than delegate '{0}'
diagnostics.Add(ErrorCode.ERR_BadVisDelegateParam, delegateType.Locations[0], delegateType, parameter.Type);
}
}
diagnostics.Add(delegateType.Locations[0], useSiteDiagnostics);
}
protected SourceUserDefinedOperatorSymbolBase(
MethodKind methodKind,
string name,
SourceMemberContainerTypeSymbol containingType,
Location location,
SyntaxReference syntaxReference,
SyntaxReference bodySyntaxReference,
SyntaxTokenList modifiersSyntax,
DiagnosticBag diagnostics,
bool isExpressionBodied) :
base(containingType, syntaxReference, bodySyntaxReference, location)
{
_name = name;
_isExpressionBodied = isExpressionBodied;
var defaultAccess = DeclarationModifiers.Private;
var allowedModifiers =
DeclarationModifiers.AccessibilityMask |
DeclarationModifiers.Static |
DeclarationModifiers.Extern |
DeclarationModifiers.Unsafe;
bool modifierErrors;
var declarationModifiers = ModifierUtils.MakeAndCheckNontypeMemberModifiers(
modifiersSyntax, defaultAccess, allowedModifiers, location, diagnostics, out modifierErrors);
this.CheckUnsafeModifier(declarationModifiers, diagnostics);
// We will bind the formal parameters and the return type lazily. For now,
// assume that the return type is non-void; when we do the lazy initialization
// of the parameters and return type we will update the flag if necessary.
this.MakeFlags(methodKind, declarationModifiers, returnsVoid: false, isExtensionMethod: false);
if (this.ContainingType.IsInterface)
{
// If we have an operator in an interface, we already have reported that fact as
// an error. No need to cascade the error further.
return;
}
if (this.ContainingType.IsStatic)
{
// Similarly if we're in a static class, though we have not reported it yet.
// CS0715: '{0}': static classes cannot contain user-defined operators
diagnostics.Add(ErrorCode.ERR_OperatorInStaticClass, location, this);
return;
}
// SPEC: An operator declaration must include both a public and a
// SPEC: static modifier
if (this.DeclaredAccessibility != Accessibility.Public || !this.IsStatic)
{
// CS0558: User-defined operator '...' must be declared static and public
diagnostics.Add(ErrorCode.ERR_OperatorsMustBeStatic, this.Locations[0], this);
}
// SPEC: Because an external operator provides no actual implementation,
// SPEC: its operator body consists of a semicolon. For expression-bodied
// SPEC: operators, the body is an expression. For all other operators,
// SPEC: the operator body consists of a block...
if (bodySyntaxReference != null && IsExtern)
{
diagnostics.Add(ErrorCode.ERR_ExternHasBody, location, this);
}
else if (bodySyntaxReference == null && !IsExtern && !IsAbstract && !IsPartial)
{
// Do not report that the body is missing if the operator is marked as
// partial or abstract; we will already have given an error for that so
// there's no need to "cascade" the error.
diagnostics.Add(ErrorCode.ERR_ConcreteMissingBody, location, this);
}
// SPEC: It is an error for the same modifier to appear multiple times in an
// SPEC: operator declaration.
var info = ModifierUtils.CheckAccessibility(this.DeclarationModifiers);
if (info != null)
{
diagnostics.Add(info, location);
}
}
public SynthesizedRecordObjEquals(SourceMemberContainerTypeSymbol containingType, MethodSymbol typedRecordEquals, int memberOffset, DiagnosticBag diagnostics)
: base(containingType, WellKnownMemberNames.ObjectEquals, memberOffset, diagnostics)
{
_typedRecordEquals = typedRecordEquals;
}
private static bool IsReadOnly(SourceMemberContainerTypeSymbol containingType, ImmutableArray <Symbol> positionalMembers)
{
return(containingType.IsReadOnly || (containingType.IsRecordStruct && !positionalMembers.Any(static m => hasNonReadOnlyGetter(m))));
internal static SourcePropertySymbol Create(SourceMemberContainerTypeSymbol containingType, Binder bodyBinder, PropertyDeclarationSyntax syntax, DiagnosticBag diagnostics)
{
var nameToken = syntax.Identifier;
var location = nameToken.GetLocation();
return new SourcePropertySymbol(containingType, bodyBinder, syntax, nameToken.ValueText, location, diagnostics);
}
public SynthesizedRecordEqualityOperator(SourceMemberContainerTypeSymbol containingType, int memberOffset, BindingDiagnosticBag diagnostics)
: base(containingType, WellKnownMemberNames.EqualityOperatorName, memberOffset, diagnostics)
{
}
// CONSIDER: if the parameters were computed lazily, ParameterCount could be overridden to fall back on the syntax (as in SourceMemberMethodSymbol).
private SourcePropertySymbol(
SourceMemberContainerTypeSymbol containingType,
Binder bodyBinder,
BasePropertyDeclarationSyntax syntax,
string name,
Location location,
DiagnosticBag diagnostics)
{
// This has the value that IsIndexer will ultimately have, once we've populated the fields of this object.
bool isIndexer = syntax.Kind() == SyntaxKind.IndexerDeclaration;
var interfaceSpecifier = GetExplicitInterfaceSpecifier(syntax);
bool isExplicitInterfaceImplementation = (interfaceSpecifier != null);
_location = location;
_containingType = containingType;
_syntaxRef = syntax.GetReference();
SyntaxTokenList modifiers = syntax.Modifiers;
bodyBinder = bodyBinder.WithUnsafeRegionIfNecessary(modifiers);
bodyBinder = bodyBinder.WithAdditionalFlagsAndContainingMemberOrLambda(BinderFlags.SuppressConstraintChecks, this);
bool modifierErrors;
_modifiers = MakeModifiers(modifiers, isExplicitInterfaceImplementation, isIndexer, location, diagnostics, out modifierErrors);
this.CheckAccessibility(location, diagnostics);
this.CheckModifiers(location, isIndexer, diagnostics);
if (isIndexer && !isExplicitInterfaceImplementation)
{
// Evaluate the attributes immediately in case the IndexerNameAttribute has been applied.
// NOTE: we want IsExplicitInterfaceImplementation, IsOverride, Locations, and the syntax reference
// to be initialized before we pass this symbol to LoadCustomAttributes.
// CONSIDER: none of the information from this early binding pass is cached. Everything will
// be re-bound when someone calls GetAttributes. If this gets to be a problem, we could
// always use the real attribute bag of this symbol and modify LoadAndValidateAttributes to
// handle partially filled bags.
CustomAttributesBag<CSharpAttributeData> temp = null;
LoadAndValidateAttributes(OneOrMany.Create(this.CSharpSyntaxNode.AttributeLists), ref temp, earlyDecodingOnly: true);
if (temp != null)
{
Debug.Assert(temp.IsEarlyDecodedWellKnownAttributeDataComputed);
var propertyData = (PropertyEarlyWellKnownAttributeData)temp.EarlyDecodedWellKnownAttributeData;
if (propertyData != null)
{
_sourceName = propertyData.IndexerName;
}
}
}
string aliasQualifierOpt;
string memberName = ExplicitInterfaceHelpers.GetMemberNameAndInterfaceSymbol(bodyBinder, interfaceSpecifier, name, diagnostics, out _explicitInterfaceType, out aliasQualifierOpt);
_sourceName = _sourceName ?? memberName; //sourceName may have been set while loading attributes
_name = isIndexer ? ExplicitInterfaceHelpers.GetMemberName(WellKnownMemberNames.Indexer, _explicitInterfaceType, aliasQualifierOpt) : _sourceName;
_isExpressionBodied = false;
bool hasAccessorList = syntax.AccessorList != null;
var propertySyntax = syntax as PropertyDeclarationSyntax;
var arrowExpression = propertySyntax != null
? propertySyntax.ExpressionBody
: ((IndexerDeclarationSyntax)syntax).ExpressionBody;
bool hasExpressionBody = arrowExpression != null;
bool hasInitializer = !isIndexer && propertySyntax.Initializer != null;
bool notRegularProperty = (!IsAbstract && !IsExtern && !isIndexer && hasAccessorList);
AccessorDeclarationSyntax getSyntax = null;
AccessorDeclarationSyntax setSyntax = null;
if (hasAccessorList)
{
foreach (var accessor in syntax.AccessorList.Accessors)
{
if (accessor.Kind() == SyntaxKind.GetAccessorDeclaration &&
(getSyntax == null || getSyntax.Keyword.Span.IsEmpty))
{
getSyntax = accessor;
}
else if (accessor.Kind() == SyntaxKind.SetAccessorDeclaration &&
(setSyntax == null || setSyntax.Keyword.Span.IsEmpty))
{
setSyntax = accessor;
}
else
{
continue;
}
if (accessor.Body != null)
{
notRegularProperty = false;
}
}
}
else
{
notRegularProperty = false;
}
if (hasInitializer)
{
CheckInitializer(hasExpressionBody, notRegularProperty, location, diagnostics);
}
if (notRegularProperty || hasInitializer)
{
var hasGetSyntax = getSyntax != null;
_isAutoProperty = notRegularProperty && hasGetSyntax;
bool isReadOnly = hasGetSyntax && setSyntax == null;
if (_isAutoProperty || hasInitializer)
{
if (_isAutoProperty)
{
//issue a diagnostic if the compiler generated attribute ctor is not found.
Binder.ReportUseSiteDiagnosticForSynthesizedAttribute(bodyBinder.Compilation,
WellKnownMember.System_Runtime_CompilerServices_CompilerGeneratedAttribute__ctor, diagnostics, syntax: syntax);
}
string fieldName = GeneratedNames.MakeBackingFieldName(_sourceName);
_backingField = new SynthesizedBackingFieldSymbol(this,
fieldName,
isReadOnly,
this.IsStatic,
hasInitializer);
}
if (notRegularProperty)
{
Binder.CheckFeatureAvailability(location,
isReadOnly ? MessageID.IDS_FeatureReadonlyAutoImplementedProperties :
MessageID.IDS_FeatureAutoImplementedProperties,
diagnostics);
}
}
PropertySymbol explicitlyImplementedProperty = null;
_typeCustomModifiers = ImmutableArray<CustomModifier>.Empty;
// The runtime will not treat the accessors of this property as overrides or implementations
// of those of another property unless both the signatures and the custom modifiers match.
// Hence, in the case of overrides and *explicit* implementations, we need to copy the custom
// modifiers that are in the signatures of the overridden/implemented property accessors.
// (From source, we know that there can only be one overridden/implemented property, so there
// are no conflicts.) This is unnecessary for implicit implementations because, if the custom
// modifiers don't match, we'll insert bridge methods for the accessors (explicit implementations
// that delegate to the implicit implementations) with the correct custom modifiers
// (see SourceNamedTypeSymbol.ImplementInterfaceMember).
// Note: we're checking if the syntax indicates explicit implementation rather,
// than if explicitInterfaceType is null because we don't want to look for an
// overridden property if this is supposed to be an explicit implementation.
if (isExplicitInterfaceImplementation || this.IsOverride)
{
// Type and parameters for overrides and explicit implementations cannot be bound
// lazily since the property name depends on the metadata name of the base property,
// and the property name is required to add the property to the containing type, and
// the type and parameters are required to determine the override or implementation.
_lazyType = this.ComputeType(bodyBinder, syntax, diagnostics);
_lazyParameters = this.ComputeParameters(bodyBinder, syntax, diagnostics);
bool isOverride = false;
PropertySymbol overriddenOrImplementedProperty = null;
if (!isExplicitInterfaceImplementation)
{
// If this property is an override, we may need to copy custom modifiers from
// the overridden property (so that the runtime will recognize it as an override).
// We check for this case here, while we can still modify the parameters and
// return type without losing the appearance of immutability.
isOverride = true;
overriddenOrImplementedProperty = this.OverriddenProperty;
}
else
{
string interfacePropertyName = isIndexer ? WellKnownMemberNames.Indexer : name;
explicitlyImplementedProperty = this.FindExplicitlyImplementedProperty(_explicitInterfaceType, interfacePropertyName, interfaceSpecifier, diagnostics);
overriddenOrImplementedProperty = explicitlyImplementedProperty;
}
if ((object)overriddenOrImplementedProperty != null)
{
_typeCustomModifiers = overriddenOrImplementedProperty.TypeCustomModifiers;
TypeSymbol overriddenPropertyType = overriddenOrImplementedProperty.Type;
// We do an extra check before copying the type to handle the case where the overriding
// property (incorrectly) has a different type than the overridden property. In such cases,
// we want to retain the original (incorrect) type to avoid hiding the type given in source.
if (_lazyType.Equals(overriddenPropertyType, ignoreCustomModifiersAndArraySizesAndLowerBounds: true, ignoreDynamic: false))
{
_lazyType = overriddenPropertyType;
}
_lazyParameters = CustomModifierUtils.CopyParameterCustomModifiers(overriddenOrImplementedProperty.Parameters, _lazyParameters, alsoCopyParamsModifier: isOverride);
}
}
if (!hasAccessorList)
{
if (hasExpressionBody)
{
_isExpressionBodied = true;
_getMethod = SourcePropertyAccessorSymbol.CreateAccessorSymbol(
containingType,
this,
_modifiers,
_sourceName,
arrowExpression,
explicitlyImplementedProperty,
aliasQualifierOpt,
diagnostics);
}
else
{
_getMethod = null;
}
_setMethod = null;
}
else
{
_getMethod = CreateAccessorSymbol(getSyntax, explicitlyImplementedProperty, aliasQualifierOpt, notRegularProperty, diagnostics);
_setMethod = CreateAccessorSymbol(setSyntax, explicitlyImplementedProperty, aliasQualifierOpt, notRegularProperty, diagnostics);
if ((getSyntax == null) || (setSyntax == null))
{
if ((getSyntax == null) && (setSyntax == null))
{
diagnostics.Add(ErrorCode.ERR_PropertyWithNoAccessors, location, this);
}
else if (notRegularProperty)
{
var accessor = _getMethod ?? _setMethod;
if (getSyntax == null)
{
diagnostics.Add(ErrorCode.ERR_AutoPropertyMustHaveGetAccessor, accessor.Locations[0], accessor);
}
}
}
// Check accessor accessibility is more restrictive than property accessibility.
CheckAccessibilityMoreRestrictive(_getMethod, diagnostics);
CheckAccessibilityMoreRestrictive(_setMethod, diagnostics);
if (((object)_getMethod != null) && ((object)_setMethod != null))
{
// Check accessibility is set on at most one accessor.
if ((_getMethod.LocalAccessibility != Accessibility.NotApplicable) &&
(_setMethod.LocalAccessibility != Accessibility.NotApplicable))
{
diagnostics.Add(ErrorCode.ERR_DuplicatePropertyAccessMods, location, this);
}
else if (this.IsAbstract)
{
// Check abstract property accessors are not private.
CheckAbstractPropertyAccessorNotPrivate(_getMethod, diagnostics);
CheckAbstractPropertyAccessorNotPrivate(_setMethod, diagnostics);
}
}
else
{
if (!this.IsOverride)
{
var accessor = _getMethod ?? _setMethod;
if ((object)accessor != null)
{
// Check accessibility is not set on the one accessor.
if (accessor.LocalAccessibility != Accessibility.NotApplicable)
{
diagnostics.Add(ErrorCode.ERR_AccessModMissingAccessor, location, this);
}
}
}
}
}
if ((object)explicitlyImplementedProperty != null)
{
CheckExplicitImplementationAccessor(this.GetMethod, explicitlyImplementedProperty.GetMethod, explicitlyImplementedProperty, diagnostics);
CheckExplicitImplementationAccessor(this.SetMethod, explicitlyImplementedProperty.SetMethod, explicitlyImplementedProperty, diagnostics);
}
_explicitInterfaceImplementations =
(object)explicitlyImplementedProperty == null ?
ImmutableArray<PropertySymbol>.Empty :
ImmutableArray.Create(explicitlyImplementedProperty);
// get-only auto property should not override settable properties
if (_isAutoProperty && (object)_setMethod == null && !this.IsReadOnly)
{
diagnostics.Add(ErrorCode.ERR_AutoPropertyMustOverrideSet, location, this);
}
}
internal SourceFieldLikeEventSymbol(SourceMemberContainerTypeSymbol containingType, Binder binder, SyntaxTokenList modifiers, VariableDeclaratorSyntax declaratorSyntax, BindingDiagnosticBag diagnostics)
: base(containingType, declaratorSyntax, modifiers, isFieldLike: true, interfaceSpecifierSyntaxOpt: null,
nameTokenSyntax: declaratorSyntax.Identifier, diagnostics: diagnostics)
{
Debug.Assert(declaratorSyntax.Parent is object);
_name = declaratorSyntax.Identifier.ValueText;
var declaratorDiagnostics = BindingDiagnosticBag.GetInstance();
var declarationSyntax = (VariableDeclarationSyntax)declaratorSyntax.Parent;
_type = BindEventType(binder, declarationSyntax.Type, declaratorDiagnostics);
// The runtime will not treat the accessors of this event as overrides or implementations
// of those of another event unless both the signatures and the custom modifiers match.
// Hence, in the case of overrides and *explicit* implementations (not possible for field-like
// events), we need to copy the custom modifiers that are in the signatures of the
// overridden/implemented event accessors. (From source, we know that there can only be one
// overridden/implemented event, so there are no conflicts.) This is unnecessary for implicit
// implementations because, if the custom modifiers don't match, we'll insert bridge methods
// for the accessors (explicit implementations that delegate to the implicit implementations)
// with the correct custom modifiers (see SourceMemberContainerTypeSymbol.SynthesizeInterfaceMemberImplementation).
// If this event is an override, we may need to copy custom modifiers from
// the overridden event (so that the runtime will recognize it as an override).
// We check for this case here, while we can still modify the parameters and
// return type without losing the appearance of immutability.
if (this.IsOverride)
{
EventSymbol?overriddenEvent = this.OverriddenEvent;
if ((object?)overriddenEvent != null)
{
CopyEventCustomModifiers(overriddenEvent, ref _type, ContainingAssembly);
}
}
bool hasInitializer = declaratorSyntax.Initializer != null;
bool inInterfaceType = containingType.IsInterfaceType();
if (hasInitializer)
{
if (inInterfaceType && !this.IsStatic)
{
diagnostics.Add(ErrorCode.ERR_InterfaceEventInitializer, this.Locations[0], this);
}
else if (this.IsAbstract)
{
diagnostics.Add(ErrorCode.ERR_AbstractEventInitializer, this.Locations[0], this);
}
else if (this.IsExtern)
{
diagnostics.Add(ErrorCode.ERR_ExternEventInitializer, this.Locations[0], this);
}
}
// NOTE: if there's an initializer in source, we'd better create a backing field, regardless of
// whether or not the initializer is legal.
if (hasInitializer || !(this.IsExtern || this.IsAbstract))
{
AssociatedEventField = MakeAssociatedField(declaratorSyntax);
// Don't initialize this.type - we'll just use the type of the field (which is lazy and handles var)
}
if (!IsStatic && ContainingType.IsReadOnly)
{
diagnostics.Add(ErrorCode.ERR_FieldlikeEventsInRoStruct, this.Locations[0]);
}
if (inInterfaceType)
{
if (IsAbstract && IsStatic)
{
if (!ContainingAssembly.RuntimeSupportsStaticAbstractMembersInInterfaces)
{
diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportStaticAbstractMembersInInterfaces, this.Locations[0]);
}
}
else if (this.IsExtern || this.IsStatic)
{
if (!ContainingAssembly.RuntimeSupportsDefaultInterfaceImplementation)
{
diagnostics.Add(ErrorCode.ERR_RuntimeDoesNotSupportDefaultInterfaceImplementation, this.Locations[0]);
}
}
else if (!this.IsAbstract)
{
diagnostics.Add(ErrorCode.ERR_EventNeedsBothAccessors, this.Locations[0], this);
}
}
// Accessors will assume that Type is available.
_addMethod = new SynthesizedEventAccessorSymbol(this, isAdder: true);
_removeMethod = new SynthesizedEventAccessorSymbol(this, isAdder: false);
if (declarationSyntax.Variables[0] == declaratorSyntax)
{
// Don't report these diagnostics for every declarator in this declaration.
diagnostics.AddRange(declaratorDiagnostics);
}
declaratorDiagnostics.Free();
}
public SynthesizedRecordConstructor(
SourceMemberContainerTypeSymbol containingType,
RecordDeclarationSyntax syntax,
DiagnosticBag diagnostics) :
base(containingType, syntax.ParameterList !.GetLocation(), syntax)
internal static void AddDelegateMembers(
SourceMemberContainerTypeSymbol delegateType,
ArrayBuilder <Symbol> symbols,
DelegateDeclarationSyntax syntax,
BindingDiagnosticBag diagnostics)
{
var compilation = delegateType.DeclaringCompilation;
Binder binder = delegateType.GetBinder(syntax.ParameterList);
RefKind refKind;
TypeSyntax returnTypeSyntax = syntax.ReturnType.SkipRef(out refKind);
var returnType = binder.BindType(returnTypeSyntax, diagnostics);
// reuse types to avoid reporting duplicate errors if missing:
var voidType = TypeWithAnnotations.Create(binder.GetSpecialType(SpecialType.System_Void, diagnostics, syntax));
// https://github.com/dotnet/roslyn/issues/30079: Should the 'object', IAsyncResult and AsyncCallback parameters be considered nullable or not nullable?
var objectType = TypeWithAnnotations.Create(binder.GetSpecialType(SpecialType.System_Object, diagnostics, syntax));
var intPtrType = TypeWithAnnotations.Create(binder.GetSpecialType(SpecialType.System_IntPtr, diagnostics, syntax));
if (returnType.IsRestrictedType(ignoreSpanLikeTypes: true))
{
// The return type of a method, delegate, or function pointer cannot be '{0}'
diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, returnTypeSyntax.Location, returnType.Type);
}
// A delegate has the following members: (see CLI spec 13.6)
// (1) a method named Invoke with the specified signature
var invoke = new InvokeMethod(delegateType, refKind, returnType, syntax, binder, diagnostics);
invoke.CheckDelegateVarianceSafety(diagnostics);
symbols.Add(invoke);
// (2) a constructor with argument types (object, System.IntPtr)
symbols.Add(new Constructor(delegateType, voidType, objectType, intPtrType, syntax));
if (binder.Compilation.GetSpecialType(SpecialType.System_IAsyncResult).TypeKind != TypeKind.Error &&
binder.Compilation.GetSpecialType(SpecialType.System_AsyncCallback).TypeKind != TypeKind.Error &&
// WinRT delegates don't have Begin/EndInvoke methods
!delegateType.IsCompilationOutputWinMdObj())
{
var iAsyncResultType = TypeWithAnnotations.Create(binder.GetSpecialType(SpecialType.System_IAsyncResult, diagnostics, syntax));
var asyncCallbackType = TypeWithAnnotations.Create(binder.GetSpecialType(SpecialType.System_AsyncCallback, diagnostics, syntax));
// (3) BeginInvoke
symbols.Add(new BeginInvokeMethod(invoke, iAsyncResultType, objectType, asyncCallbackType, syntax));
// and (4) EndInvoke methods
symbols.Add(new EndInvokeMethod(invoke, iAsyncResultType, syntax));
}
if (delegateType.DeclaredAccessibility <= Accessibility.Private)
{
return;
}
var useSiteInfo = new CompoundUseSiteInfo <AssemblySymbol>(diagnostics, delegateType.ContainingAssembly);
if (!delegateType.IsNoMoreVisibleThan(invoke.ReturnTypeWithAnnotations, ref useSiteInfo))
{
// Inconsistent accessibility: return type '{1}' is less accessible than delegate '{0}'
diagnostics.Add(ErrorCode.ERR_BadVisDelegateReturn, delegateType.Locations[0], delegateType, invoke.ReturnType);
}
for (int i = 0; i < invoke.Parameters.Length; i++)
{
var parameterSymbol = invoke.Parameters[i];
if (!parameterSymbol.TypeWithAnnotations.IsAtLeastAsVisibleAs(delegateType, ref useSiteInfo))
{
// Inconsistent accessibility: parameter type '{1}' is less accessible than delegate '{0}'
diagnostics.Add(ErrorCode.ERR_BadVisDelegateParam, delegateType.Locations[0], delegateType, parameterSymbol.Type);
}
}
diagnostics.Add(delegateType.Locations[0], useSiteInfo);
}