private void ComputeParameters()
{
if (_lazyParameters != null)
{
return;
}
SyntaxToken arglistToken;
var diagnostics = DiagnosticBag.GetInstance();
var parameters = ParameterHelpers.MakeParameters(
_binder,
this,
_syntax.ParameterList,
arglistToken: out arglistToken,
allowRefOrOut: true,
allowThis: true,
addRefReadOnlyModifier: false,
diagnostics: diagnostics);
ParameterHelpers.EnsureIsReadOnlyAttributeExists(parameters, diagnostics, modifyCompilation: false);
ParameterHelpers.EnsureNullableAttributeExists(parameters, diagnostics, 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
var isVararg = arglistToken.Kind() == SyntaxKind.ArgListKeyword;
if (isVararg)
{
diagnostics.Add(ErrorCode.ERR_IllegalVarArgs, arglistToken.GetLocation());
}
if (IsAsync)
{
SourceOrdinaryMethodSymbol.ReportAsyncParameterErrors(parameters, diagnostics, this.Locations[0]);
}
lock (_declarationDiagnostics)
{
if (_lazyParameters != null)
{
diagnostics.Free();
return;
}
_declarationDiagnostics.AddRangeAndFree(diagnostics);
_lazyIsVarArg = isVararg;
_lazyParameters = parameters;
}
}
internal InvokeMethod(
SourceMemberContainerTypeSymbol delegateType,
RefKind refKind,
TypeSymbolWithAnnotations returnType,
DelegateDeclarationSyntax syntax,
Binder binder,
DiagnosticBag diagnostics)
: base(delegateType, returnType, syntax, MethodKind.DelegateInvoke, DeclarationModifiers.Virtual | DeclarationModifiers.Public)
{
this._refKind = refKind;
SyntaxToken arglistToken;
var parameters = ParameterHelpers.MakeParameters(
binder, this, syntax.ParameterList, out arglistToken,
allowRefOrOut: true,
allowThis: false,
addRefReadOnlyModifier: true,
diagnostics: diagnostics);
if (arglistToken.Kind() == SyntaxKind.ArgListKeyword)
{
// This is a parse-time error in the native compiler; it is a semantic analysis error in Roslyn.
// error CS1669: __arglist is not valid in this context
diagnostics.Add(ErrorCode.ERR_IllegalVarArgs, new SourceLocation(arglistToken));
}
if (_refKind == RefKind.RefReadOnly)
{
var modifierType = binder.GetWellKnownType(WellKnownType.core_runtime_InAttribute, diagnostics, syntax.ReturnType);
_refCustomModifiers = ImmutableArray.Create(CSharpCustomModifier.CreateRequired(modifierType));
}
else
{
_refCustomModifiers = ImmutableArray <CustomModifier> .Empty;
}
InitializeParameters(parameters);
}
protected override void MethodChecks(DiagnosticBag diagnostics)
{
var syntax = GetSyntax();
var binderFactory = this.DeclaringCompilation.GetBinderFactory(syntax.SyntaxTree);
ParameterListSyntax parameterList = syntax.ParameterList;
// NOTE: if we asked for the binder for the body of the constructor, we'd risk a stack overflow because
// we might still be constructing the member list of the containing type. However, getting the binder
// for the parameters should be safe.
var bodyBinder = binderFactory.GetBinder(parameterList, syntax, this).WithContainingMemberOrLambda(this);
SyntaxToken arglistToken;
_lazyParameters = ParameterHelpers.MakeParameters(
bodyBinder, this, parameterList, out arglistToken,
allowRefOrOut: true,
allowThis: false,
addRefReadOnlyModifier: false,
diagnostics: diagnostics);
_lazyIsVararg = (arglistToken.Kind() == SyntaxKind.ArgListKeyword);
_lazyReturnType = TypeSymbolWithAnnotations.Create(bodyBinder.GetSpecialType(SpecialType.System_Void, diagnostics, syntax));
var location = this.Locations[0];
if (MethodKind == MethodKind.StaticConstructor && (_lazyParameters.Length != 0))
{
diagnostics.Add(ErrorCode.ERR_StaticConstParam, location, this);
}
this.CheckEffectiveAccessibility(_lazyReturnType, _lazyParameters, diagnostics);
if (_lazyIsVararg && (IsGenericMethod || ContainingType.IsGenericType || _lazyParameters.Length > 0 && _lazyParameters[_lazyParameters.Length - 1].IsParams))
{
diagnostics.Add(ErrorCode.ERR_BadVarargs, location);
}
}
protected override void MethodChecks(DiagnosticBag diagnostics)
{
var binder = this.DeclaringCompilation.
GetBinderFactory(syntaxReferenceOpt.SyntaxTree).GetBinder(ReturnTypeSyntax, GetSyntax(), this);
SyntaxToken arglistToken;
var signatureBinder = binder.WithAdditionalFlags(BinderFlags.SuppressConstraintChecks);
_lazyParameters = ParameterHelpers.MakeParameters(
signatureBinder,
this,
ParameterListSyntax,
out arglistToken,
allowRefOrOut: true,
allowThis: false,
addRefReadOnlyModifier: false,
diagnostics: diagnostics);
if (arglistToken.Kind() == SyntaxKind.ArgListKeyword)
{
// This is a parse-time error in the native compiler; it is a semantic analysis error in Roslyn.
// error CS1669: __arglist is not valid in this context
diagnostics.Add(ErrorCode.ERR_IllegalVarArgs, new SourceLocation(arglistToken));
// Regardless of whether __arglist appears in the source code, we do not mark
// the operator method as being a varargs method.
}
_lazyReturnType = signatureBinder.BindType(ReturnTypeSyntax, diagnostics);
// restricted types cannot be returned.
// NOTE: Span-like types can be returned (if expression is returnable).
if (_lazyReturnType.IsRestrictedType(ignoreSpanLikeTypes: true))
{
// Method or delegate cannot return type '{0}'
diagnostics.Add(ErrorCode.ERR_MethodReturnCantBeRefAny, ReturnTypeSyntax.Location, _lazyReturnType.TypeSymbol);
}
if (_lazyReturnType.TypeSymbol.IsStatic)
{
// '{0}': static types cannot be used as return types
diagnostics.Add(ErrorCode.ERR_ReturnTypeIsStaticClass, ReturnTypeSyntax.Location, _lazyReturnType.TypeSymbol);
}
this.SetReturnsVoid(_lazyReturnType.SpecialType == SpecialType.System_Void);
// If we have an operator in an interface or static class then we already
// have reported that fact as an error. No need to cascade the error further.
if (this.ContainingType.IsInterfaceType() || this.ContainingType.IsStatic)
{
return;
}
// SPEC: All types referenced in an operator declaration must be at least as accessible
// SPEC: as the operator itself.
CheckEffectiveAccessibility(_lazyReturnType, _lazyParameters, diagnostics);
CheckValueParameters(diagnostics);
CheckOperatorSignatures(diagnostics);
}