private SourceUserDefinedOperatorSymbol(
MethodKind methodKind,
SourceMemberContainerTypeSymbol containingType,
TypeSymbol explicitInterfaceType,
string name,
Location location,
OperatorDeclarationSyntax syntax,
bool isNullableAnalysisEnabled,
BindingDiagnosticBag diagnostics) :
base(
methodKind,
explicitInterfaceType,
name,
containingType,
location,
syntax,
MakeDeclarationModifiers(methodKind, containingType.IsInterface, syntax, location, diagnostics),
hasBody: syntax.HasAnyBody(),
isExpressionBodied: syntax.Body == null && syntax.ExpressionBody != null,
isIterator: SyntaxFacts.HasYieldOperations(syntax.Body),
isNullableAnalysisEnabled: isNullableAnalysisEnabled,
diagnostics)
{
CheckForBlockAndExpressionBody(
syntax.Body, syntax.ExpressionBody, syntax, diagnostics);
if (IsAbstract || (name != WellKnownMemberNames.EqualityOperatorName && name != WellKnownMemberNames.InequalityOperatorName))
{
CheckFeatureAvailabilityAndRuntimeSupport(syntax, location, hasBody: syntax.Body != null || syntax.ExpressionBody != null, diagnostics: diagnostics);
}
}
internal SourceCustomEventAccessorSymbol(
SourceEventSymbol @event,
AccessorDeclarationSyntax syntax,
EventSymbol explicitlyImplementedEventOpt,
string aliasQualifierOpt,
DiagnosticBag diagnostics)
: base(@event,
syntax.GetReference(),
ImmutableArray.Create(syntax.Keyword.GetLocation()), explicitlyImplementedEventOpt, aliasQualifierOpt,
isAdder: syntax.Kind() == SyntaxKind.AddAccessorDeclaration,
isIterator: SyntaxFacts.HasYieldOperations(syntax.Body))
{
Debug.Assert(syntax != null);
Debug.Assert(syntax.Kind() == SyntaxKind.AddAccessorDeclaration || syntax.Kind() == SyntaxKind.RemoveAccessorDeclaration);
CheckFeatureAvailabilityAndRuntimeSupport(syntax, this.Location, hasBody: true, diagnostics: diagnostics);
if (syntax.Body != null || syntax.ExpressionBody != null)
{
if (IsExtern && !IsAbstract)
{
diagnostics.Add(ErrorCode.ERR_ExternHasBody, this.Location, this);
}
// Do not report error for IsAbstract && IsExtern. Dev10 reports CS0180 only
// in that case ("member cannot be both extern and abstract").
}
if (syntax.Modifiers.Count > 0)
{
diagnostics.Add(ErrorCode.ERR_NoModifiersOnAccessor, syntax.Modifiers[0].GetLocation());
}
CheckForBlockAndExpressionBody(
syntax.Body, syntax.ExpressionBody, syntax, diagnostics);
}
private SourceUserDefinedConversionSymbol(
SourceMemberContainerTypeSymbol containingType,
string name,
Location location,
ConversionOperatorDeclarationSyntax syntax,
bool isNullableAnalysisEnabled,
BindingDiagnosticBag diagnostics) :
base(
MethodKind.Conversion,
name,
containingType,
location,
syntax,
MakeDeclarationModifiers(syntax, location, diagnostics),
hasBody: syntax.HasAnyBody(),
isExpressionBodied: syntax.Body == null && syntax.ExpressionBody != null,
isIterator: SyntaxFacts.HasYieldOperations(syntax.Body),
isNullableAnalysisEnabled: isNullableAnalysisEnabled,
diagnostics)
{
CheckForBlockAndExpressionBody(
syntax.Body, syntax.ExpressionBody, syntax, diagnostics);
if (syntax.ParameterList.Parameters.Count != 1)
{
diagnostics.Add(ErrorCode.ERR_OvlUnaryOperatorExpected, syntax.ParameterList.GetLocation());
}
}
private SourceConstructorSymbol(
SourceMemberContainerTypeSymbol containingType,
Location location,
ConstructorDeclarationSyntax syntax,
MethodKind methodKind,
bool isNullableAnalysisEnabled,
BindingDiagnosticBag diagnostics) :
base(containingType, location, syntax, SyntaxFacts.HasYieldOperations(syntax))
{
bool hasBlockBody = syntax.Body != null;
_isExpressionBodied = !hasBlockBody && syntax.ExpressionBody != null;
bool hasBody = hasBlockBody || _isExpressionBodied;
_hasThisInitializer = syntax.Initializer?.Kind() == SyntaxKind.ThisConstructorInitializer;
bool modifierErrors;
var declarationModifiers = this.MakeModifiers(syntax.Modifiers, methodKind, hasBody, location, diagnostics, out modifierErrors);
this.MakeFlags(methodKind, declarationModifiers, returnsVoid: true, isExtensionMethod: false, isNullableAnalysisEnabled: isNullableAnalysisEnabled);
if (syntax.Identifier.ValueText != containingType.Name)
{
// This is probably a method declaration with the type missing.
diagnostics.Add(ErrorCode.ERR_MemberNeedsType, location);
}
if (IsExtern)
{
if (methodKind == MethodKind.Constructor && syntax.Initializer != null)
{
diagnostics.Add(ErrorCode.ERR_ExternHasConstructorInitializer, location, this);
}
if (hasBody)
{
diagnostics.Add(ErrorCode.ERR_ExternHasBody, location, this);
}
}
if (methodKind == MethodKind.StaticConstructor)
{
CheckFeatureAvailabilityAndRuntimeSupport(syntax, location, hasBody, diagnostics);
}
var info = ModifierUtils.CheckAccessibility(this.DeclarationModifiers, this, isExplicitInterfaceImplementation: false);
if (info != null)
{
diagnostics.Add(info, location);
}
if (!modifierErrors)
{
this.CheckModifiers(methodKind, hasBody, location, diagnostics);
}
CheckForBlockAndExpressionBody(
syntax.Body, syntax.ExpressionBody, syntax, diagnostics);
}
private SourceUserDefinedOperatorSymbol(
SourceMemberContainerTypeSymbol containingType,
string name,
Location location,
OperatorDeclarationSyntax syntax,
DiagnosticBag diagnostics) :
base(
MethodKind.UserDefinedOperator,
name,
containingType,
location,
syntax,
MakeDeclarationModifiers(syntax, location, diagnostics),
hasBody: syntax.HasAnyBody(),
isExpressionBodied: syntax.Body == null && syntax.ExpressionBody != null,
isIterator: SyntaxFacts.HasYieldOperations(syntax.Body),
diagnostics)
{
CheckForBlockAndExpressionBody(
syntax.Body, syntax.ExpressionBody, syntax, diagnostics);
if (name != WellKnownMemberNames.EqualityOperatorName && name != WellKnownMemberNames.InequalityOperatorName)
{
CheckFeatureAvailabilityAndRuntimeSupport(syntax, location, hasBody: syntax.Body != null || syntax.ExpressionBody != null, diagnostics: diagnostics);
}
}
public static SourcePropertyAccessorSymbol CreateAccessorSymbol(
NamedTypeSymbol containingType,
SourcePropertySymbol property,
DeclarationModifiers propertyModifiers,
string propertyName,
AccessorDeclarationSyntax syntax,
PropertySymbol explicitlyImplementedPropertyOpt,
string aliasQualifierOpt,
bool isAutoPropertyAccessor,
bool isExplicitInterfaceImplementation,
DiagnosticBag diagnostics)
{
Debug.Assert(syntax.Kind() == SyntaxKind.GetAccessorDeclaration ||
syntax.Kind() == SyntaxKind.SetAccessorDeclaration ||
syntax.Kind() == SyntaxKind.InitAccessorDeclaration);
bool isGetMethod = (syntax.Kind() == SyntaxKind.GetAccessorDeclaration);
string name;
ImmutableArray <MethodSymbol> explicitInterfaceImplementations;
GetNameAndExplicitInterfaceImplementations(
explicitlyImplementedPropertyOpt,
propertyName,
property.IsCompilationOutputWinMdObj(),
aliasQualifierOpt,
isGetMethod,
out name,
out explicitInterfaceImplementations);
var methodKind = isGetMethod ? MethodKind.PropertyGet : MethodKind.PropertySet;
bool hasBody = syntax.Body is object;
bool hasExpressionBody = syntax.ExpressionBody is object;
bool isNullableAnalysisEnabled = containingType.DeclaringCompilation.IsNullableAnalysisEnabledIn(syntax);
CheckForBlockAndExpressionBody(syntax.Body, syntax.ExpressionBody, syntax, diagnostics);
return(new SourcePropertyAccessorSymbol(
containingType,
name,
property,
propertyModifiers,
explicitInterfaceImplementations,
syntax.Keyword.GetLocation(),
syntax,
hasBody,
hasExpressionBody,
isIterator: SyntaxFacts.HasYieldOperations(syntax.Body),
syntax.Modifiers,
methodKind,
syntax.Keyword.IsKind(SyntaxKind.InitKeyword),
isAutoPropertyAccessor,
isExplicitInterfaceImplementation,
isNullableAnalysisEnabled: isNullableAnalysisEnabled,
diagnostics));
}
private SourceOrdinaryMethodSymbol(
NamedTypeSymbol containingType,
TypeSymbol explicitInterfaceType,
string name,
Location location,
MethodDeclarationSyntax syntax,
MethodKind methodKind,
DiagnosticBag diagnostics) :
base(containingType,
name,
location,
syntax,
methodKind,
isIterator: SyntaxFacts.HasYieldOperations(syntax.Body),
isExtensionMethod: syntax.ParameterList.Parameters.FirstOrDefault() is ParameterSyntax firstParam &&
public static SourcePropertyAccessorSymbol CreateAccessorSymbol(
NamedTypeSymbol containingType,
SourcePropertySymbol property,
DeclarationModifiers propertyModifiers,
AccessorDeclarationSyntax syntax,
bool isAutoPropertyAccessor,
BindingDiagnosticBag diagnostics
)
{
Debug.Assert(
syntax.Kind() == SyntaxKind.GetAccessorDeclaration ||
syntax.Kind() == SyntaxKind.SetAccessorDeclaration ||
syntax.Kind() == SyntaxKind.InitAccessorDeclaration
);
bool isGetMethod = (syntax.Kind() == SyntaxKind.GetAccessorDeclaration);
var methodKind = isGetMethod ? MethodKind.PropertyGet : MethodKind.PropertySet;
bool hasBody = syntax.Body is object;
bool hasExpressionBody = syntax.ExpressionBody is object;
bool isNullableAnalysisEnabled =
containingType.DeclaringCompilation.IsNullableAnalysisEnabledIn(syntax);
CheckForBlockAndExpressionBody(syntax.Body, syntax.ExpressionBody, syntax, diagnostics);
return(new SourcePropertyAccessorSymbol(
containingType,
property,
propertyModifiers,
syntax.Keyword.GetLocation(),
syntax,
hasBody,
hasExpressionBody,
isIterator: SyntaxFacts.HasYieldOperations(syntax.Body),
syntax.Modifiers,
methodKind,
syntax.Keyword.IsKind(SyntaxKind.InitKeyword),
isAutoPropertyAccessor,
isNullableAnalysisEnabled: isNullableAnalysisEnabled,
diagnostics
));
}
private SourceUserDefinedConversionSymbol(
MethodKind methodKind,
SourceMemberContainerTypeSymbol containingType,
TypeSymbol explicitInterfaceType,
string name,
Location location,
ConversionOperatorDeclarationSyntax syntax,
bool isNullableAnalysisEnabled,
BindingDiagnosticBag diagnostics) :
base(
methodKind,
explicitInterfaceType,
name,
containingType,
location,
syntax,
MakeDeclarationModifiers(methodKind, containingType.IsInterface, syntax, location, diagnostics),
hasBody: syntax.HasAnyBody(),
isExpressionBodied: syntax.Body == null && syntax.ExpressionBody != null,
isIterator: SyntaxFacts.HasYieldOperations(syntax.Body),
isNullableAnalysisEnabled: isNullableAnalysisEnabled,
diagnostics)
{
CheckForBlockAndExpressionBody(
syntax.Body, syntax.ExpressionBody, syntax, diagnostics);
if (syntax.ParameterList.Parameters.Count != 1)
{
diagnostics.Add(ErrorCode.ERR_OvlUnaryOperatorExpected, syntax.ParameterList.GetLocation());
}
if (IsStatic && (IsAbstract || IsVirtual))
{
CheckFeatureAvailabilityAndRuntimeSupport(syntax, location, hasBody: syntax.Body != null || syntax.ExpressionBody != null, diagnostics: diagnostics);
}
}
public LocalFunctionSymbol(
Binder binder,
Symbol containingSymbol,
LocalFunctionStatementSyntax syntax)
: base(syntax.GetReference())
{
_containingSymbol = containingSymbol;
_declarationDiagnostics = new BindingDiagnosticBag();
_declarationModifiers =
DeclarationModifiers.Private |
syntax.Modifiers.ToDeclarationModifiers(diagnostics: _declarationDiagnostics.DiagnosticBag);
if (SyntaxFacts.HasYieldOperations(syntax.Body))
{
_lazyIteratorElementType = TypeWithAnnotations.Boxed.Sentinel;
}
this.CheckUnsafeModifier(_declarationModifiers, _declarationDiagnostics);
ScopeBinder = binder;
binder = binder.WithUnsafeRegionIfNecessary(syntax.Modifiers);
if (syntax.TypeParameterList != null)
{
binder = new WithMethodTypeParametersBinder(this, binder);
_typeParameters = MakeTypeParameters(_declarationDiagnostics);
}
else
{
_typeParameters = ImmutableArray <SourceMethodTypeParameterSymbol> .Empty;
ReportErrorIfHasConstraints(syntax.ConstraintClauses, _declarationDiagnostics.DiagnosticBag);
}
if (IsExtensionMethod)
{
_declarationDiagnostics.Add(ErrorCode.ERR_BadExtensionAgg, Locations[0]);
}
foreach (var param in syntax.ParameterList.Parameters)
{
ReportAttributesDisallowed(param.AttributeLists, _declarationDiagnostics);
}
if (syntax.ReturnType.Kind() == SyntaxKind.RefType)
{
var returnType = (RefTypeSyntax)syntax.ReturnType;
if (returnType.ReadOnlyKeyword.Kind() == SyntaxKind.ReadOnlyKeyword)
{
_refKind = RefKind.RefReadOnly;
}
else
{
_refKind = RefKind.Ref;
}
}
else
{
_refKind = RefKind.None;
}
_binder = binder;
}
internal SourceDestructorSymbol(
SourceMemberContainerTypeSymbol containingType,
DestructorDeclarationSyntax syntax,
bool isNullableAnalysisEnabled,
DiagnosticBag diagnostics) :
base(containingType, syntax.GetReference(), syntax.Identifier.GetLocation(), isIterator: SyntaxFacts.HasYieldOperations(syntax.Body))
{
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, isNullableAnalysisEnabled: isNullableAnalysisEnabled);
if (syntax.Identifier.ValueText != containingType.Name)
{
diagnostics.Add(ErrorCode.ERR_BadDestructorName, syntax.Identifier.GetLocation());
}
bool hasBlockBody = syntax.Body != null;
_isExpressionBodied = !hasBlockBody && syntax.ExpressionBody != null;
if (hasBlockBody || _isExpressionBodied)
{
if (IsExtern)
{
diagnostics.Add(ErrorCode.ERR_ExternHasBody, location, this);
}
}
if (!modifierErrors && !hasBlockBody && !_isExpressionBodied && !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);
}
CheckForBlockAndExpressionBody(
syntax.Body, syntax.ExpressionBody, syntax, diagnostics);
}
protected SourceConstructorSymbolBase(
SourceMemberContainerTypeSymbol containingType,
Location location,
CSharpSyntaxNode syntax,
MethodKind methodKind,
DiagnosticBag diagnostics)
: base(containingType, syntax.GetReference(), ImmutableArray.Create(location), SyntaxFacts.HasYieldOperations(syntax))
{
Debug.Assert(
syntax.IsKind(SyntaxKind.ConstructorDeclaration) ||
syntax.IsKind(SyntaxKind.RecordDeclaration));
}
protected SourceUserDefinedOperatorSymbolBase(
MethodKind methodKind,
string name,
SourceMemberContainerTypeSymbol containingType,
Location location,
BaseMethodDeclarationSyntax syntax,
DiagnosticBag diagnostics) :
base(containingType, syntax.GetReference(), location, isIterator: SyntaxFacts.HasYieldOperations(syntax.Body))
{
_name = name;
_isExpressionBodied = syntax.Body == null && syntax.ExpressionBody != null;
var defaultAccess = DeclarationModifiers.Private;
var allowedModifiers =
DeclarationModifiers.AccessibilityMask |
DeclarationModifiers.Static |
DeclarationModifiers.Extern |
DeclarationModifiers.Unsafe;
bool modifierErrors;
var declarationModifiers = ModifierUtils.MakeAndCheckNontypeMemberModifiers(
syntax.Modifiers, 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 &&
(methodKind == MethodKind.Conversion || name == WellKnownMemberNames.EqualityOperatorName || name == WellKnownMemberNames.InequalityOperatorName))
{
// If we have a conversion or equality/inequality 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...
bool hasBody = syntax.HasAnyBody();
if (hasBody && IsExtern)
{
diagnostics.Add(ErrorCode.ERR_ExternHasBody, location, this);
}
else if (!hasBody && !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, this, isExplicitInterfaceImplementation: false);
if (info != null)
{
diagnostics.Add(info, location);
}
}
private SourcePropertyAccessorSymbol(
NamedTypeSymbol containingType,
string name,
SourcePropertySymbol property,
DeclarationModifiers propertyModifiers,
ImmutableArray <MethodSymbol> explicitInterfaceImplementations,
Location location,
AccessorDeclarationSyntax syntax,
MethodKind methodKind,
bool isAutoPropertyAccessor,
bool isExplicitInterfaceImplementation,
DiagnosticBag diagnostics)
: base(containingType,
syntax.GetReference(),
location,
isIterator: SyntaxFacts.HasYieldOperations(syntax.Body))
{
_property = property;
_explicitInterfaceImplementations = explicitInterfaceImplementations;
_name = name;
_isAutoPropertyAccessor = isAutoPropertyAccessor;
Debug.Assert(!_property.IsExpressionBodied, "Cannot have accessors in expression bodied lightweight properties");
var hasBody = syntax.Body != null;
var hasExpressionBody = syntax.ExpressionBody != null;
_isExpressionBodied = !hasBody && hasExpressionBody;
bool modifierErrors;
var declarationModifiers = this.MakeModifiers(syntax, isExplicitInterfaceImplementation, hasBody || hasExpressionBody, location, diagnostics, out modifierErrors);
// Include some modifiers from the containing property, but not the accessibility modifiers.
declarationModifiers |= GetAccessorModifiers(propertyModifiers) & ~DeclarationModifiers.AccessibilityMask;
if ((declarationModifiers & DeclarationModifiers.Private) != 0)
{
// Private accessors cannot be virtual.
declarationModifiers &= ~DeclarationModifiers.Virtual;
}
// ReturnsVoid property is overridden in this class so
// returnsVoid argument to MakeFlags is ignored.
this.MakeFlags(methodKind, declarationModifiers, returnsVoid: false, isExtensionMethod: false,
isMetadataVirtualIgnoringModifiers: explicitInterfaceImplementations.Any());
CheckFeatureAvailabilityAndRuntimeSupport(syntax, location, hasBody: hasBody || hasExpressionBody || isAutoPropertyAccessor, diagnostics);
if (hasBody || hasExpressionBody)
{
CheckModifiersForBody(syntax, location, diagnostics);
}
var info = ModifierUtils.CheckAccessibility(this.DeclarationModifiers, this, isExplicitInterfaceImplementation);
if (info != null)
{
diagnostics.Add(info, location);
}
if (!modifierErrors)
{
this.CheckModifiers(location, hasBody || hasExpressionBody, isAutoPropertyAccessor, diagnostics);
}
if (this.IsOverride)
{
MethodSymbol overriddenMethod = this.OverriddenMethod;
if ((object)overriddenMethod != null)
{
// If this accessor is overriding a method from metadata, it is possible that
// the name of the overridden method doesn't follow the C# get_X/set_X pattern.
// We should copy the name so that the runtime will recognize this as an override.
_name = overriddenMethod.Name;
}
}
CheckForBlockAndExpressionBody(
syntax.Body, syntax.ExpressionBody, syntax, diagnostics);
}
