public static FunctionPointerMethodSymbol CreateFromSource(
FunctionPointerTypeSyntax syntax,
Binder typeBinder,
BindingDiagnosticBag diagnostics,
ConsList <TypeSymbol> basesBeingResolved,
bool suppressUseSiteDiagnostics
)
{
ArrayBuilder <CustomModifier> customModifiers =
ArrayBuilder <CustomModifier> .GetInstance();
CallingConvention callingConvention = getCallingConvention(
typeBinder.Compilation,
syntax.CallingConvention,
customModifiers,
diagnostics
);
RefKind refKind = RefKind.None;
TypeWithAnnotations returnType;
if (syntax.ParameterList.Parameters.Count == 0)
{
returnType = TypeWithAnnotations.Create(typeBinder.CreateErrorType());
}
else
{
FunctionPointerParameterSyntax?returnTypeParameter =
syntax.ParameterList.Parameters[^ 1];
private Doc PrintFunctionPointerTypeSyntax(
FunctionPointerTypeSyntax node)
{
return(Concat(
this.PrintSyntaxToken(node.DelegateKeyword),
this.PrintSyntaxToken(node.AsteriskToken, " "),
node.CallingConvention != null
? this.PrintCallingConvention(node.CallingConvention)
: Doc.Null,
this.PrintSyntaxToken(node.ParameterList.LessThanToken),
Indent(
Group(
SoftLine,
this.PrintSeparatedSyntaxList(
node.ParameterList.Parameters,
o => Concat(
this.PrintAttributeLists(o, o.AttributeLists),
this.PrintModifiers(o.Modifiers),
this.Print(o.Type)
),
Line
)
)
),
this.PrintSyntaxToken(node.ParameterList.GreaterThanToken)
));
}
public static Doc Print(FunctionPointerTypeSyntax node)
{
return(Doc.Concat(
Token.Print(node.DelegateKeyword),
Token.Print(node.AsteriskToken, " "),
node.CallingConvention != null
? PrintCallingConvention(node.CallingConvention)
: Doc.Null,
Token.Print(node.ParameterList.LessThanToken),
Doc.Indent(
Doc.Group(
Doc.SoftLine,
SeparatedSyntaxList.Print(
node.ParameterList.Parameters,
o =>
Doc.Concat(
AttributeLists.Print(o, o.AttributeLists),
Modifiers.Print(o.Modifiers),
Node.Print(o.Type)
),
Doc.Line
)
)
),
Token.Print(node.ParameterList.GreaterThanToken)
));
}
public static FunctionPointerTypeSymbol CreateFromSource(FunctionPointerTypeSyntax syntax, Binder typeBinder, DiagnosticBag diagnostics, ConsList <TypeSymbol> basesBeingResolved, bool suppressUseSiteDiagnostics)
=> new FunctionPointerTypeSymbol(
FunctionPointerMethodSymbol.CreateFromSource(
syntax,
typeBinder,
diagnostics,
basesBeingResolved,
suppressUseSiteDiagnostics));
public static FunctionPointerMethodSymbol CreateFromSource(FunctionPointerTypeSyntax syntax, Binder typeBinder, DiagnosticBag diagnostics, ConsList <TypeSymbol> basesBeingResolved, bool suppressUseSiteDiagnostics)
{
var(callingConvention, conventionIsValid) = FunctionPointerTypeSymbol.GetCallingConvention(syntax.CallingConvention.Text);
if (!conventionIsValid)
{
// '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'.
diagnostics.Add(ErrorCode.ERR_InvalidFunctionPointerCallingConvention, syntax.CallingConvention.GetLocation(), syntax.CallingConvention.Text);
}
RefKind refKind = RefKind.None;
TypeWithAnnotations returnType;
var refReadonlyModifiers = ImmutableArray <CustomModifier> .Empty;
if (syntax.Parameters.Count == 0)
{
returnType = TypeWithAnnotations.Create(typeBinder.CreateErrorType());
}
else
{
var returnTypeParameter = syntax.Parameters[^ 1];
/// <inheritdoc/>
public override SyntaxNode?VisitFunctionPointerType(FunctionPointerTypeSyntax node)
{
Diagnostics.Add(FunctionPointer, node);
return(base.VisitFunctionPointerType(node));
}
public override void VisitFunctionPointerType(FunctionPointerTypeSyntax node) => base.VisitFunctionPointerType(node);
public override void VisitFunctionPointerType(FunctionPointerTypeSyntax node)
{
Log(node, "Unsupported Syntax !");
}
/// <inheritdoc/>
public override SyntaxNode?VisitFunctionPointerType(FunctionPointerTypeSyntax node)
{
Context.ReportDiagnostic(FunctionPointer, node);
return(base.VisitFunctionPointerType(node));
}
