private IEnumerable <StatementSyntax> GenerateConstructorBody(DiscriminatedUnionContext <StructDiscriminatedUnionCase> context)
{
if (!context.IsSingleCase)
{
yield return(ExpressionStatement(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(GeneratorHelpers.TagFieldName),
IdentifierName("tag")
)
));
}
var valueAssignments = context.Cases.SelectMany(
@case => @case.CaseValues.Select(
@caseValue => ExpressionStatement(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
ThisExpression(),
IdentifierName(@caseValue.Name)
),
IdentifierName(caseValue.Name)
)
)
)
);
foreach (var valueAssigment in valueAssignments)
{
yield return(valueAssigment);
}
}
private StatementSyntax GenerateEqualsStatements(DiscriminatedUnionContext <StructDiscriminatedUnionCase> context)
{
return(ReturnStatement(
BinaryExpression(
SyntaxKind.LogicalAndExpression,
BinaryExpression(
SyntaxKind.IsExpression,
IdentifierName("obj"),
context.Type
),
InvocationExpression(
IdentifierName("Equals"),
ArgumentList(
SingletonSeparatedList(
Argument(
CastExpression(
context.Type,
IdentifierName("obj")
)
)
)
)
)
)
));
}
private MemberDeclarationSyntax CreateCaseFactoryMethod(
DiscriminatedUnionContext <T> context,
T singleCase)
{
return(MethodDeclaration(
context.Type,
_prefix + singleCase.Name)
.WithModifiers(
TokenList(
Token(SyntaxKind.PublicKeyword),
Token(SyntaxKind.StaticKeyword)
)
)
.WithParameterList(
ParameterList(
SeparatedList(
singleCase.CaseValues.Select(p =>
Parameter(p.Name).WithType(p.Type)
)
)
)
)
.WithBody(
Block(
GenerateCreateCaseFactoryBlock(context, singleCase)
)
)
);
}
private IEnumerable <StatementSyntax> GenerateGetHashCodeBody(DiscriminatedUnionContext <StructDiscriminatedUnionCase> context)
{
yield return(DeclarePrimeConstant());
yield return(DeclareHashCodeVariable());
if (!context.IsSingleCase)
{
var tag = MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
ThisExpression(),
IdentifierName(GeneratorHelpers.TagFieldName)
);
yield return(GenerateHashCodeForFieldValue(tag));
var switchCases = context.Cases.Select(c => GetSwitchCase(c, context.SemanticModel));
yield return(SwitchStatement(tag)
.WithSections(
List(switchCases)
));
}
else
{
foreach (var s in context.Cases[0].CaseValues.Select(c => GenerateHashCodeForFieldValue(HashCodeForCaseValue(c, context.SemanticModel))))
{
yield return(s);
}
}
yield return(ReturnStatement(IdentifierName(Identifier(HashCodeVariable))));
}
private static MemberDeclarationSyntax DeclareOperator(
DiscriminatedUnionContext <T> context,
SyntaxKind operatorSyntaxKind,
IEnumerable <StatementSyntax> body)
{
return(OperatorDeclaration(
PredefinedType(Token(SyntaxKind.BoolKeyword)),
Token(operatorSyntaxKind)
)
.WithParameterList(
ParameterList(
SeparatedList <ParameterSyntax>(
new[]
{
Parameter(Identifier("left")).WithType(context.Type),
Parameter(Identifier("right")).WithType(context.Type)
}
)
)
)
.WithModifiers(
TokenList(
Token(SyntaxKind.PublicKeyword),
Token(SyntaxKind.StaticKeyword)
)
)
.WithBody(Block(body)));
}
public DiscriminatedUnionContext <T> Build(DiscriminatedUnionContext <T> context)
{
var constructor = ConstructorDeclaration(context.UserDefinedClass.Identifier)
.AddModifiers(Token(SyntaxKind.PrivateKeyword))
.WithBody(Block());
return(context.AddMember(constructor));
}
public DiscriminatedUnionContext <DiscriminatedUnionCase> Build(DiscriminatedUnionContext <DiscriminatedUnionCase> context)
{
var cases = context.Cases
.Select(c => c.AddMember(CreateCasePartialClassConstructor(c)))
.ToImmutableArray();
return(context.WithCases(cases));
}
public DiscriminatedUnionContext <DiscriminatedUnionCase> Build(DiscriminatedUnionContext <DiscriminatedUnionCase> context)
{
if (context.Cases.IsEmpty)
{
return(context);
}
return(context.AddMember(GetAbstractMatchMethod(context)));
}
private IEnumerable <ParameterSyntax> GetValueParameters(DiscriminatedUnionContext <StructDiscriminatedUnionCase> context)
{
return(context.Cases.SelectMany(
@case => @case.CaseValues.Select(
@caseValue => Parameter(caseValue.Name).WithType(caseValue.Type)
)
));
}
public DiscriminatedUnionContext <T> Build(DiscriminatedUnionContext <T> context)
{
if (context.Cases.IsEmpty)
{
return(context);
}
return(context.AddMember(GenerateDebugViewProperty(context))
.AddAttributeLists(GeneratorHelpers.CreateDebuggerDisplayAttributeList()));
}
public DiscriminatedUnionContext <T> Build(DiscriminatedUnionContext <T> context)
{
if (context.Cases.Length <= 1)
{
//we don't need a tag if there is zero or one case
return(context);
}
return(context.AddMember(TagField));
}
public DiscriminatedUnionContext <StructDiscriminatedUnionCase> Build(DiscriminatedUnionContext <StructDiscriminatedUnionCase> context)
{
var block = Block(GenerateEquatableBlock(context));
var method = GeneratorHelpers.GenerateEquatableImplementation(context.Type, ParameterName)
.WithModifiers(TokenList(Token(SyntaxKind.PublicKeyword)))
.WithBody(block);
return(context.AddMember(method));
}
public DiscriminatedUnionContext <T> Build(DiscriminatedUnionContext <T> context)
{
return(context.AddMembers(
new[]
{
GenerateEqualsOperatorOverload(context),
GenerateNotEqualsOperatorOverload(context)
}));
}
public DiscriminatedUnionContext <DiscriminatedUnionCase> Build(DiscriminatedUnionContext <DiscriminatedUnionCase> context)
{
if (context.Cases.IsEmpty)
{
return(context);
}
var newCases = context.Cases.Select(c => c.AddMember(GetMatchImplementation(context, c)))
.ToImmutableArray();
return(context.WithCases(newCases));
}
public DiscriminatedUnionContext <DiscriminatedUnionCase> Build(DiscriminatedUnionContext <DiscriminatedUnionCase> context)
{
return(context.WithCases(
context.Cases.Select(c => c.AddMember(GenerateEqualsImplementation(
context.Type,
c,
context.Cases,
context.SemanticModel
))).ToImmutableArray()
));
}
private static ExpressionSyntax GeneratePropertyExpression(DiscriminatedUnionContext <T> context)
{
return(InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
ThisExpression(),
IdentifierName("Match")
)
)
.WithArgumentList(ArgumentList(SeparatedList(context.Cases.Select(c => Argument(GenerateCaseFunc(c)))))));
}
private static ExpressionSyntax GenerateSingletonInitializer(
DiscriminatedUnionContext <DiscriminatedUnionCase> context,
DiscriminatedUnionCase @case)
{
return(ObjectCreationExpression(
QualifiedName(
IdentifierName("Cases"),
IdentifierName(@case.Name)
)
)
.WithArgumentList(ArgumentList()));
}
private static MemberDeclarationSyntax GetMatchMethod(DiscriminatedUnionContext <StructDiscriminatedUnionCase> context)
{
var match = GeneratorHelpers.CreateMatchMethod(context.Cases.Cast <IDiscriminatedUnionCase>(), context.MatchGenericParameter)
.WithModifiers(
TokenList(
Token(SyntaxKind.PublicKeyword)
)
)
.WithBody(GetMatchBlock(context.Cases));
return(match);
}
private static IEnumerable <StatementSyntax> GenerateBody(DiscriminatedUnionContext <T> context)
{
yield return(GeneratorHelpers.CreateGuardForNull(IdentifierName("none")));
var callMatch = InvocationExpression(IdentifierName("Match"))
.WithArgumentList(
ArgumentList(
SeparatedList(context.Cases.Select(c => Argument(GenerateMatchInvocation(c))))
)
);
yield return(ReturnStatement(callMatch));
}
private static MemberDeclarationSyntax GetAbstractMatchMethod(DiscriminatedUnionContext <DiscriminatedUnionCase> context)
{
var match = GeneratorHelpers.CreateMatchMethod(context.Cases.Cast <IDiscriminatedUnionCase>(), context.MatchGenericParameter)
.WithModifiers(
TokenList(
Token(SyntaxKind.PublicKeyword),
Token(SyntaxKind.AbstractKeyword)
)
)
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken));
return(match);
}
private IEnumerable <StatementSyntax> GenerateCreateCaseFactoryBlock(
DiscriminatedUnionContext <T> context,
T singleCase)
{
if (_preventNull)
{
foreach (var caseValue in singleCase.CaseValues.Where(c => CanHaveNullGuard(c)))
{
var c = caseValue;
yield return(GeneratorHelpers.CreateGuardForNull(IdentifierName(c.Name)));
}
}
yield return(ReturnStatement(_generateFactoryMethodReturnStatement(context, singleCase)));
}
private static MemberDeclarationSyntax GetMatchImplementation(
DiscriminatedUnionContext <DiscriminatedUnionCase> context,
DiscriminatedUnionCase currentCase)
{
var match = GeneratorHelpers.CreateMatchMethod(context.Cases.Cast <IDiscriminatedUnionCase>(), context.MatchGenericParameter)
.WithModifiers(
TokenList(
Token(SyntaxKind.PublicKeyword),
Token(SyntaxKind.OverrideKeyword)
)
)
.WithBody(GetMatchBlock(context.Cases, currentCase));
return(match);
}
private IEnumerable <MemberDeclarationSyntax> AddCasesMembers(DiscriminatedUnionContext <T> context)
{
return(context.Cases.Select(c =>
{
MemberDeclarationSyntax member;
if (c.CaseValues.Length == 0)
{
member = CreateSingleCaseSingleton(context, c);
}
else
{
member = CreateCaseFactoryMethod(context, c);
}
return member;
}));
}
private static ExpressionSyntax GenerateSingletonInitializer(
DiscriminatedUnionContext <StructDiscriminatedUnionCase> context,
StructDiscriminatedUnionCase @case)
{
var defaultArguments = context.Cases.SelectMany(c => c.CaseValues.Select(cc => Argument(DefaultExpression(cc.Type))));
var tagArgument = context.IsSingleCase ? Enumerable.Empty <ArgumentSyntax>()
: new[] { CreateTagArgument(@case) };
return(ObjectCreationExpression(context.Type)
.WithArgumentList(
ArgumentList(
SeparatedList(
tagArgument.Concat(defaultArguments)
)
)
));
}
public DiscriminatedUnionContext <T> Build(DiscriminatedUnionContext <T> context)
{
if (!context.IsGeneric)
{
return(context);
}
var typedParameters = context.SymbolInfo
.TypeParameters
.Select(t => TypeParameter(t.Name));
var newContext = context.WithTypeParameterList(
TypeParameterList(
SeparatedList(typedParameters)
)
);
return(newContext);
}
private IEnumerable <StatementSyntax> GenerateEquatableBlock(DiscriminatedUnionContext <StructDiscriminatedUnionCase> context)
{
if (!context.IsSingleCase)
{
yield return(GeneratorHelpers.GenerateStructMatchingSwitchStatement(
context.Cases.Cast <IDiscriminatedUnionCase>(),
d => GenerateReturnStatement(d, context.SemanticModel)));
}
else if (context.Cases.IsEmpty)
{
yield return(ReturnStatement(GeneratorHelpers.TrueExpression()));
}
else
{
yield return(GenerateReturnStatementForSingleCase(context.Cases[0], context.SemanticModel));
}
}
public DiscriminatedUnionContext <T> Build(DiscriminatedUnionContext <T> context)
{
return(context.AddMember(
MethodDeclaration(
PredefinedType(
Token(SyntaxKind.IntKeyword)
),
Identifier("GetHashCode")
)
.WithModifiers(
TokenList(
new[] {
Token(SyntaxKind.PublicKeyword),
Token(SyntaxKind.OverrideKeyword)
}
)
)
.WithBody(
Block(
SingletonList <StatementSyntax>(
ThrowStatement(
ObjectCreationExpression(
QualifiedName(
IdentifierName("System"),
IdentifierName("InvalidOperationException")
)
)
.WithArgumentList(
ArgumentList(
SingletonSeparatedList <ArgumentSyntax>(
Argument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal("This method should not be called")
)
)
)
)
)
)
)
)
)
));
}
private static ExpressionSyntax GenerateFactoryMethodReturnStatement(
DiscriminatedUnionContext <StructDiscriminatedUnionCase> context,
StructDiscriminatedUnionCase @case)
{
var tagArgument = context.IsSingleCase ? Enumerable.Empty <ArgumentSyntax>()
: new[] { CreateTagArgument(@case) };
return(ObjectCreationExpression(context.Type)
.WithArgumentList(
ArgumentList(
SeparatedList(
tagArgument.Concat(
context.Cases.SelectMany(c => GenerateArgumentsForCase(c, @case))
)
)
)
));
}
private static ExpressionSyntax GenerateFactoryMethodReturnStatement(
DiscriminatedUnionContext <DiscriminatedUnionCase> context,
DiscriminatedUnionCase @case)
{
return(ObjectCreationExpression(
QualifiedName(
IdentifierName("Cases"),
IdentifierName(@case.Name)
)
)
.WithArgumentList(
ArgumentList(
SeparatedList(
@case.CaseValues.Select(p => Argument(IdentifierName(p.Name)))
)
)
));
}
private static StatementSyntax GenerateEqualsStatements(DiscriminatedUnionContext <T> context)
{
return(ReturnStatement(
InvocationExpression(
IdentifierName("Equals"),
ArgumentList(
SingletonSeparatedList(
Argument(
BinaryExpression(
SyntaxKind.AsExpression,
IdentifierName("obj"),
context.Type
)
)
)
)
)
));
}
