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)); }