private static OperatorDeclarationSyntax GenerateOperatorDeclarationWorker(
IMethodSymbol method,
CodeGenerationDestination destination,
CodeGenerationOptions options)
{
var hasNoBody = !options.GenerateMethodBodies || method.IsExtern;
var operatorSyntaxKind = SyntaxFacts.GetOperatorKind(method.MetadataName);
if (operatorSyntaxKind == SyntaxKind.None)
{
throw new ArgumentException(string.Format(WorkspacesResources.Cannot_generate_code_for_unsupported_operator_0, method.Name), nameof(method));
}
var operatorToken = SyntaxFactory.Token(operatorSyntaxKind);
return(SyntaxFactory.OperatorDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(method.GetAttributes(), options),
modifiers: GenerateModifiers(method),
returnType: method.ReturnType.GenerateTypeSyntax(),
operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword),
operatorToken: operatorToken,
parameterList: ParameterGenerator.GenerateParameterList(method.Parameters, isExplicit: false, options: options),
body: hasNoBody ? null : StatementGenerator.GenerateBlock(method),
semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : new SyntaxToken()));
}
private static string ToDisplayString(IMethodSymbol symbol)
{
using var _ = PooledStringBuilder.GetInstance(out var builder);
switch (symbol.MethodKind)
{
case MethodKind.Ordinary:
builder.Append(symbol.Name);
break;
case MethodKind.UserDefinedOperator:
case MethodKind.BuiltinOperator:
AppendOperatorKeywords(symbol, builder);
builder.Append(SyntaxFacts.GetText(SyntaxFacts.GetOperatorKind(symbol.MetadataName)));
break;
case MethodKind.Conversion:
AppendOperatorKeywords(symbol, builder);
AddType(symbol.ReturnType, builder);
break;
}
AddTypeArguments(symbol, builder);
builder.Append('(');
AddParameters(symbol.Parameters, builder);
builder.Append(')');
return(builder.ToString());
private static ConversionOperatorDeclarationSyntax GenerateConversionDeclarationWorker(
IMethodSymbol method,
CodeGenerationDestination destination,
CodeGenerationOptions options)
{
var hasNoBody = !options.GenerateMethodBodies || method.IsExtern;
var reusableSyntax = GetReuseableSyntaxNodeForSymbol <ConversionOperatorDeclarationSyntax>(method, options);
if (reusableSyntax != null)
{
return(reusableSyntax);
}
var operatorToken = SyntaxFactory.Token(SyntaxFacts.GetOperatorKind(method.MetadataName));
var keyword = method.MetadataName == WellKnownMemberNames.ImplicitConversionName
? SyntaxFactory.Token(SyntaxKind.ImplicitKeyword)
: SyntaxFactory.Token(SyntaxKind.ExplicitKeyword);
return(SyntaxFactory.ConversionOperatorDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(method.GetAttributes(), options),
modifiers: GenerateModifiers(method),
implicitOrExplicitKeyword: keyword,
operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword),
type: method.ReturnType.GenerateTypeSyntax(),
parameterList: ParameterGenerator.GenerateParameterList(method.Parameters, isExplicit: false, options: options),
body: hasNoBody ? null : StatementGenerator.GenerateBlock(method),
semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : new SyntaxToken()));
}
private static OperatorDeclarationSyntax GenerateOperatorDeclarationWorker(
IMethodSymbol method,
CodeGenerationDestination destination,
CSharpCodeGenerationContextInfo info)
{
var hasNoBody = !info.Context.GenerateMethodBodies || method.IsExtern || method.IsAbstract;
var operatorSyntaxKind = SyntaxFacts.GetOperatorKind(method.MetadataName);
if (operatorSyntaxKind == SyntaxKind.None)
{
throw new ArgumentException(string.Format(WorkspacesResources.Cannot_generate_code_for_unsupported_operator_0, method.Name), nameof(method));
}
var operatorToken = SyntaxFactory.Token(operatorSyntaxKind);
var checkedToken = SyntaxFacts.IsCheckedOperator(method.MetadataName)
? SyntaxFactory.Token(SyntaxKind.CheckedKeyword)
: default;
var operatorDecl = SyntaxFactory.OperatorDeclaration(
attributeLists: AttributeGenerator.GenerateAttributeLists(method.GetAttributes(), info),
modifiers: GenerateModifiers(method, destination, hasNoBody),
returnType: method.ReturnType.GenerateTypeSyntax(),
explicitInterfaceSpecifier: GenerateExplicitInterfaceSpecifier(method.ExplicitInterfaceImplementations),
operatorKeyword: SyntaxFactory.Token(SyntaxKind.OperatorKeyword),
checkedKeyword: checkedToken,
operatorToken: operatorToken,
parameterList: ParameterGenerator.GenerateParameterList(method.Parameters, isExplicit: false, info: info),
body: hasNoBody ? null : StatementGenerator.GenerateBlock(method),
expressionBody: null,
semicolonToken: hasNoBody ? SyntaxFactory.Token(SyntaxKind.SemicolonToken) : new SyntaxToken());
operatorDecl = UseExpressionBodyIfDesired(info, operatorDecl);
return(operatorDecl);
}
public static SourceUserDefinedOperatorSymbol CreateUserDefinedOperatorSymbol(
SourceMemberContainerTypeSymbol containingType,
Binder bodyBinder,
OperatorDeclarationSyntax syntax,
bool isNullableAnalysisEnabled,
BindingDiagnosticBag diagnostics)
{
var location = syntax.OperatorToken.GetLocation();
string name = OperatorFacts.OperatorNameFromDeclaration(syntax);
if (SyntaxFacts.IsCheckedOperator(name))
{
MessageID.IDS_FeatureCheckedUserDefinedOperators.CheckFeatureAvailability(diagnostics, syntax, syntax.CheckedKeyword.GetLocation());
}
else if (!syntax.OperatorToken.IsMissing && syntax.CheckedKeyword.IsKind(SyntaxKind.CheckedKeyword))
{
diagnostics.Add(ErrorCode.ERR_OperatorCantBeChecked, syntax.CheckedKeyword.GetLocation(), SyntaxFacts.GetText(SyntaxFacts.GetOperatorKind(name)));
}
if (name == WellKnownMemberNames.UnsignedRightShiftOperatorName)
{
MessageID.IDS_FeatureUnsignedRightShift.CheckFeatureAvailability(diagnostics, syntax, syntax.OperatorToken.GetLocation());
}
var interfaceSpecifier = syntax.ExplicitInterfaceSpecifier;
TypeSymbol explicitInterfaceType;
name = ExplicitInterfaceHelpers.GetMemberNameAndInterfaceSymbol(bodyBinder, interfaceSpecifier, name, diagnostics, out explicitInterfaceType, aliasQualifierOpt: out _);
var methodKind = interfaceSpecifier == null
? MethodKind.UserDefinedOperator
: MethodKind.ExplicitInterfaceImplementation;
return(new SourceUserDefinedOperatorSymbol(
methodKind, containingType, explicitInterfaceType, name, location, syntax, isNullableAnalysisEnabled, diagnostics));
}
