private static ExpressionSyntax GenerateCaseValueEqual(IDiscriminatedUnionCase @case, int caseValueIndex, SemanticModel semanticModel)
{
if (GeneratorHelpers.IsStructuralEquatableType(@case.CaseValues[caseValueIndex], semanticModel))
{
return(WrapEqualityWithNullGuard(@case.CaseValues[caseValueIndex], GenerateStructuralEquatableCaseValueEqual(@case.CaseValues[caseValueIndex])));
}
return(GenerateDefaultCaseValueEqual(@case.CaseValues[caseValueIndex]));
}
private ReturnStatementSyntax GenerateReturnStatementForSingleCase(IDiscriminatedUnionCase @case, SemanticModel semanticModel)
{
if (@case.CaseValues.IsEmpty)
{
return(ReturnStatement(GeneratorHelpers.TrueExpression()));
}
return(ReturnStatement(GenerateCasesBinaryExpression(@case, GenerateCaseValueEqual(@case, 0, semanticModel), semanticModel, 1)));
}
private static ParameterSyntax GetCaseMatchFunction(IDiscriminatedUnionCase @case, SyntaxToken generateParameterName)
{
return(Parameter(
Identifier("match" + @case.Name.Text)
)
.WithType(
GenericName(
Identifier("System.Func"),
TypeArgumentList(
SeparatedList(
@case.CaseValues.Select(vc => vc.Type).Concat(new[] { IdentifierName(generateParameterName) })
)
)
)
));
}
private ExpressionSyntax GenerateCasesBinaryExpression(
IDiscriminatedUnionCase @case,
ExpressionSyntax binaryExpressionSyntax,
SemanticModel semanticModel,
int caseValueIndex = 0)
{
if (@case.CaseValues.Length <= caseValueIndex)
{
return(binaryExpressionSyntax);
}
var andExpression = BinaryExpression(
SyntaxKind.LogicalAndExpression,
binaryExpressionSyntax,
GenerateCaseValueEqual(@case, caseValueIndex, semanticModel)
);
return(GenerateCasesBinaryExpression(@case, andExpression, semanticModel, caseValueIndex + 1));
}
private ReturnStatementSyntax GenerateReturnStatement(IDiscriminatedUnionCase @case, SemanticModel semanticModel)
{
return(ReturnStatement(
GenerateCasesBinaryExpression(
@case,
BinaryExpression(
SyntaxKind.EqualsExpression,
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(Identifier("value")),
IdentifierName(Identifier(GeneratorHelpers.TagFieldName))
),
LiteralExpression(
SyntaxKind.NumericLiteralExpression,
Literal(@case.CaseNumber)
)
),
semanticModel
)
));
}
public static ReturnStatementSyntax GenerateMatchReturnStatement(IDiscriminatedUnionCase currentCase)
{
return(ReturnStatement(
InvocationExpression(
IdentifierName("match" + currentCase.Name)
)
.WithArgumentList(
ArgumentList(
SeparatedList(
currentCase.CaseValues.Select(v =>
Argument(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
ThisExpression(),
IdentifierName(v.Name)
)
)
)
)
)
)
));
}
