static SyntaxNode AddMatchExtensions(EnumDeclarationSyntax enumNode, SyntaxNode root, string extensionClassName,
Option <ClassDeclarationSyntax> unionType, QualifiedTypeName unionTypeName, IEnumerable <string> caseTypeNames)
{
var classDeclaration = root
.TryGetFirstDescendant <ClassDeclarationSyntax>(n => n.Name() == extensionClassName)
.Match(ext => ext, () =>
{
var extensionClass = SyntaxFactory.ClassDeclaration(extensionClassName)
.WithModifiers(unionType.Match(u => u.Modifiers, () => enumNode.Modifiers))
.Static();
// ReSharper disable once AccessToModifiedClosure
root = root.AddMemberToNamespace(extensionClass,
m => m is ClassDeclarationSyntax clazz && clazz.QualifiedName() == unionTypeName);
return(extensionClass);
});
var derivedTypes = caseTypeNames.Select(n => new MatchMethods.DerivedType($"{unionTypeName}.{n}_", n.ToParameterName(),
$"{unionTypeName}.{WrapEnumToClass.DefaultNestedEnumTypeName}.{n}")).ToImmutableList();
classDeclaration = classDeclaration.AddMatchMethods(unionTypeName, derivedTypes);
var extClass = root.TryGetFirstDescendant <ClassDeclarationSyntax>(n => n.Name() == extensionClassName);
root = root.ReplaceNode(extClass.GetValueOrThrow(), classDeclaration);
return(root);
}
static SyntaxNode AddOrUpdateEnumClass(SyntaxNode documentRoot, string stateClassName,
string nestedEnumTypeName,
IEnumerable <string> enumMemberNames, bool addUnionTypeAttribute)
{
var stateType = documentRoot.DescendantNodes().OfType <ClassDeclarationSyntax>()
.FirstOrDefault(n => n.Name() == stateClassName);
var oldEnumDeclaration = stateType?.DescendantNodes().OfType <EnumDeclarationSyntax>()
.FirstOrDefault(e => e.Name() == nestedEnumTypeName);
if (oldEnumDeclaration == null)
{
var newEnumDeclaration = SyntaxFactory.EnumDeclaration(stateClassName)
.AddMembers(enumMemberNames.Select(SyntaxFactory.EnumMemberDeclaration).ToArray()).Public();
documentRoot = documentRoot.AddMemberToNamespace(newEnumDeclaration);
documentRoot = documentRoot.GenerateEnumClass(QualifiedTypeName.NoParents(stateClassName),
Option <ClassDeclarationSyntax> .None, addUnionTypeAttribute);
}
else
{
var newEnumDeclaration = oldEnumDeclaration
.WithMembers(SyntaxFactory.SeparatedList(
enumMemberNames.Select(SyntaxFactory.EnumMemberDeclaration).ToArray())
);
documentRoot = documentRoot.ReplaceNode(oldEnumDeclaration, newEnumDeclaration)
.UpdateEnumClass(QualifiedTypeName.NoParents(stateClassName), addUnionTypeAttribute);
}
return(documentRoot);
}
public static SyntaxNode AddTypeDeclarationIfNotExists(this SyntaxNode node, string className,
Func <BaseTypeDeclarationSyntax> createType)
{
var declaration = TypeDeclarationFinder.TryGetTypeDeclaration(node, className);
return(declaration.Match(_ => node, () => node.AddMemberToNamespace(createType())));
}
static SyntaxNode AddOrUpdateExtensionClass(SyntaxNode documentRoot, StateMachineModel names, bool funicularGeneratorsReferenced)
{
var applyMethod = GenerateApplyMethod(names);
var doTransitionMethod = GenerateDoTransitionMethod(names);
var classDeclaration = names.TryGetExtensionClass(documentRoot)
.Match(ext => ext, () =>
{
var extensionClass = SyntaxFactory.ClassDeclaration(names.ExtensionClassName)
.Public()
.Static();
documentRoot = documentRoot.AddMemberToNamespace(extensionClass);
return(extensionClass);
});
classDeclaration = classDeclaration.AddOrUpdateMethod(m => m.Identifier.ToString() == StateMachineModel.ApplyMethodName && m.ParameterList.Parameters.Count == 2, applyMethod);
classDeclaration = classDeclaration.AddOrUpdateMethod(m => m.Identifier.ToString() == StateMachineModel.DoTransitionMethodName && m.ParameterList.Parameters.Count == 2, doTransitionMethod);
if (!funicularGeneratorsReferenced)
{
classDeclaration = classDeclaration
.AddMatchMethods(
QualifiedTypeName.NoParents(names.BaseInterfaceName),
names.BaseName.ToParameterName(),
$"{StateMachineModel.StatePropertyName}.{StateMachineModel.EnumPropertyName}",
names.VertexClasses.Select(v => new MatchMethods.DerivedType(v.ClassName, v.StateName.ToParameterName(),
$"{names.OuterStateClassName}.{StateMachineModel.NestedEnumTypeName}.{v.StateName}"))
.ToImmutableList())
.AddMatchMethods(
QualifiedTypeName.NoParents(names.ParameterInterfaceName),
"parameter",
$"{StateMachineModel.TriggerPropertyName}.{StateMachineModel.EnumPropertyName}",
names.VertexClasses.SelectMany(v => v.Transitions
.Select(t => new MatchMethods.DerivedType(t.FullParameterClassName,
t.MethodName.ToParameterName(),
$"{names.OuterTriggerClassName}.{StateMachineModel.NestedEnumTypeName}.{t.MethodName}")))
.Distinct().ToImmutableList()
);
}
return(documentRoot.ReplaceNode(names.TryGetExtensionClass(documentRoot).GetValueOrThrow(), classDeclaration));
}
