internal SourceNamespaceSymbol(
SourceModuleSymbol module, Symbol container,
MergedNamespaceDeclaration mergedDeclaration,
BindingDiagnosticBag diagnostics)
{
Debug.Assert(mergedDeclaration != null);
_module = module;
_container = container;
_mergedDeclaration = mergedDeclaration;
foreach (var singleDeclaration in mergedDeclaration.Declarations)
{
diagnostics.AddRange(singleDeclaration.Diagnostics);
}
}
internal void GetDeclarationDiagnostics(BindingDiagnosticBag addTo)
{
// Force complete type parameters
foreach (var typeParam in _typeParameters)
{
typeParam.ForceComplete(null, default(CancellationToken));
}
// force lazy init
ComputeParameters();
foreach (var p in _lazyParameters)
{
// Force complete parameters to retrieve all diagnostics
p.ForceComplete(null, default(CancellationToken));
}
ComputeReturnType();
GetAttributes();
GetReturnTypeAttributes();
AsyncMethodChecks(_declarationDiagnostics);
addTo.AddRange(_declarationDiagnostics, allowMismatchInDependencyAccumulation: true);
var diagnostics = BindingDiagnosticBag.GetInstance(
withDiagnostics: false,
withDependencies: addTo.AccumulatesDependencies
);
if (
IsEntryPointCandidate &&
!IsGenericMethod &&
ContainingSymbol is SynthesizedSimpleProgramEntryPointSymbol &&
DeclaringCompilation.HasEntryPointSignature(this, diagnostics).IsCandidate
)
{
addTo.Add(ErrorCode.WRN_MainIgnored, Syntax.Identifier.GetLocation(), this);
}
addTo.AddRangeAndFree(diagnostics);
}
internal SourceNamespaceSymbol(
SourceModuleSymbol module, Symbol container,
MergedNamespaceDeclaration mergedDeclaration,
BindingDiagnosticBag diagnostics)
{
Debug.Assert(mergedDeclaration != null);
_module = module;
_container = container;
_mergedDeclaration = mergedDeclaration;
var builder = ImmutableSegmentedDictionary.CreateBuilder <SingleNamespaceDeclaration, AliasesAndUsings>(ReferenceEqualityComparer.Instance);
#if DEBUG
var builderForAsserts = ImmutableSegmentedDictionary.CreateBuilder <SingleNamespaceDeclaration, AliasesAndUsings>(ReferenceEqualityComparer.Instance);
#endif
foreach (var singleDeclaration in mergedDeclaration.Declarations)
{
if (singleDeclaration.HasExternAliases || singleDeclaration.HasGlobalUsings || singleDeclaration.HasUsings)
{
builder.Add(singleDeclaration, new AliasesAndUsings());
}
#if DEBUG
else
{
builderForAsserts.Add(singleDeclaration, new AliasesAndUsings());
}
#endif
diagnostics.AddRange(singleDeclaration.Diagnostics);
}
_aliasesAndUsings = builder.ToImmutable();
#if DEBUG
_aliasesAndUsingsForAsserts = builderForAsserts.ToImmutable();
#endif
}
internal override void AddDeclarationDiagnostics(BindingDiagnosticBag diagnostics) => _declarationDiagnostics.AddRange(diagnostics);
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 || IsVirtual) && 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();
}
