internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder <SynthesizedAttributeData> attributes)
{
base.AddSynthesizedAttributes(moduleBuilder, ref attributes);
CSharpCompilation compilation = this.DeclaringCompilation;
// do not emit CompilerGenerated attributes for fields inside compiler generated types:
if (!_containingType.IsImplicitlyDeclared)
{
AddSynthesizedAttribute(ref attributes, compilation.TrySynthesizeAttribute(WellKnownMember.System_Runtime_CompilerServices_CompilerGeneratedAttribute__ctor));
}
if (!this.SuppressDynamicAttribute &&
this.Type.ContainsDynamic() &&
compilation.HasDynamicEmitAttributes() &&
compilation.CanEmitBoolean())
{
AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(this.Type, this.TypeWithAnnotations.CustomModifiers.Length));
}
if (TypeWithAnnotations.Type.ContainsTupleNames() &&
compilation.HasTupleNamesAttributes &&
compilation.CanEmitSpecialType(SpecialType.System_String))
{
AddSynthesizedAttribute(ref attributes,
compilation.SynthesizeTupleNamesAttribute(Type));
}
if (TypeWithAnnotations.NeedsNullableAttribute())
{
AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNullableAttribute(this, this.TypeWithAnnotations));
}
}
internal override void AfterAddingTypeMembersChecks(
ConversionsBase conversions,
BindingDiagnosticBag diagnostics
)
{
var compilation = DeclaringCompilation;
var location = ErrorLocation;
if (Type.ContainsNativeInteger())
{
compilation.EnsureNativeIntegerAttributeExists(
diagnostics,
location,
modifyCompilation: true
);
}
if (
compilation.ShouldEmitNullableAttributes(this) &&
TypeWithAnnotations.NeedsNullableAttribute()
)
{
compilation.EnsureNullableAttributeExists(
diagnostics,
location,
modifyCompilation: true
);
}
}
internal override void AddSynthesizedAttributes(PEModuleBuilder moduleBuilder, ref ArrayBuilder <SynthesizedAttributeData> attributes)
{
// Emit [Dynamic] on synthesized parameter symbols when the original parameter was dynamic
// in order to facilitate debugging. In the case the necessary attributes are missing
// this is a no-op. Emitting an error here, or when the original parameter was bound, would
// adversely effect the compilation or potentially change overload resolution.
var compilation = this.DeclaringCompilation;
var type = this.TypeWithAnnotations;
if (type.Type.ContainsDynamic() && compilation.HasDynamicEmitAttributes() && compilation.CanEmitBoolean())
{
AddSynthesizedAttribute(ref attributes, compilation.SynthesizeDynamicAttribute(type.Type, type.CustomModifiers.Length + this.RefCustomModifiers.Length, this.RefKind));
}
if (type.Type.ContainsTupleNames() &&
compilation.HasTupleNamesAttributes &&
compilation.CanEmitSpecialType(SpecialType.System_String))
{
AddSynthesizedAttribute(ref attributes,
compilation.SynthesizeTupleNamesAttribute(type.Type));
}
if (TypeWithAnnotations.NeedsNullableAttribute())
{
AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeNullableAttribute(this, TypeWithAnnotations));
}
if (this.RefKind == RefKind.RefReadOnly)
{
AddSynthesizedAttribute(ref attributes, moduleBuilder.SynthesizeIsReadOnlyAttribute(this));
}
}
internal void ComputeReturnType()
{
if (_lazyReturnType is object)
{
return;
}
var diagnostics = BindingDiagnosticBag.GetInstance(_declarationDiagnostics);
TypeSyntax returnTypeSyntax = Syntax.ReturnType;
TypeWithAnnotations returnType = _binder.BindType(returnTypeSyntax.SkipRef(), diagnostics);
var compilation = DeclaringCompilation;
// Skip some diagnostics when the local function is not associated with a compilation
// (specifically, local functions nested in expressions in the EE).
if (compilation is object)
{
var location = returnTypeSyntax.Location;
if (_refKind == RefKind.RefReadOnly)
{
compilation.EnsureIsReadOnlyAttributeExists(diagnostics, location, modifyCompilation: false);
}
if (returnType.Type.ContainsNativeInteger())
{
compilation.EnsureNativeIntegerAttributeExists(diagnostics, location, modifyCompilation: false);
}
if (compilation.ShouldEmitNullableAttributes(this) &&
returnType.NeedsNullableAttribute())
{
compilation.EnsureNullableAttributeExists(diagnostics, location, modifyCompilation: false);
// Note: we don't need to warn on annotations used in #nullable disable context for local functions, as this is handled in binding already
}
}
// span-like types are returnable in general
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);
}
Debug.Assert(_refKind == RefKind.None ||
!returnType.IsVoidType() ||
returnTypeSyntax.HasErrors);
lock (_declarationDiagnostics)
{
if (_lazyReturnType is object)
{
diagnostics.Free();
return;
}
_declarationDiagnostics.AddRangeAndFree(diagnostics);
Interlocked.CompareExchange(ref _lazyReturnType, new TypeWithAnnotations.Boxed(returnType), null);
}
}
internal void ComputeReturnType()
{
if (!_lazyReturnType.IsDefault)
{
return;
}
var diagnostics = DiagnosticBag.GetInstance();
TypeSyntax returnTypeSyntax = _syntax.ReturnType;
TypeWithAnnotations returnType = _binder.BindType(returnTypeSyntax.SkipRef(), diagnostics);
if (this.IsAsync)
{
if (this.RefKind != RefKind.None)
{
ReportBadRefToken(returnTypeSyntax, diagnostics);
}
else if (returnType.Type.IsBadAsyncReturn(this.DeclaringCompilation))
{
diagnostics.Add(ErrorCode.ERR_BadAsyncReturn, this.Locations[0]);
}
}
var location = _syntax.ReturnType.Location;
if (_refKind == RefKind.RefReadOnly)
{
DeclaringCompilation.EnsureIsReadOnlyAttributeExists(diagnostics, location, modifyCompilation: false);
}
if (returnType.NeedsNullableAttribute())
{
DeclaringCompilation.EnsureNullableAttributeExists(diagnostics, location, modifyCompilation: false);
// Note: we don't need to warn on annotations used without NonNullTypes context for local functions, as this is handled in binding already
}
// span-like types are returnable in general
if (returnType.IsRestrictedType(ignoreSpanLikeTypes: true))
{
// Method or delegate cannot return type '{0}'
diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, returnTypeSyntax.Location, returnType.Type);
}
Debug.Assert(_refKind == RefKind.None ||
!returnType.IsVoidType() ||
returnTypeSyntax.HasErrors);
lock (_declarationDiagnostics)
{
if (!_lazyReturnType.IsDefault)
{
diagnostics.Free();
return;
}
_declarationDiagnostics.AddRangeAndFree(diagnostics);
_lazyReturnType = returnType;
}
}