FlagParser.cs

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using System;
using System.Collections.Generic;
using System.Linq;

namespace FlagHelper
{
    public class FlagParser
    {
        private Dictionary<string, int>? _enumCache;

        public void Parse(string input, ParseType parseType)
        {
            switch (parseType)
            {
                case ParseType.Enum:
                    _enumCache = ParseEnum(input);
                    break;

                case ParseType.Description:
                    _enumCache = ParseDescription(input);
                    break;

                default:
                    throw new ArgumentOutOfRangeException(nameof(parseType));
            }
        }

        // None (0) GettingStarted (1) Bronze (2) Silver (4) Gold (8)
        private static Dictionary<string, int> ParseDescription(string input)
        {
            var split = input.Split(' ', StringSplitOptions.RemoveEmptyEntries);

            var result = new Dictionary<string, int>();
            for (var i = 0; i < split.Length; i += 2)
            {
                string value = split[i + 1].Replace("(", "").Replace(")", "");
                result.Add(split[i], int.Parse(value));
            }

            return result;
        }

        private static Dictionary<string, int> ParseEnum(string input)
        {
            var tree = CSharpSyntaxTree.ParseText(input);

            var diagnostics = tree.GetDiagnostics();
            if (diagnostics.Any(d => d.Severity == DiagnosticSeverity.Error))
            {
                throw new CodeParseException(diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error));
            }

            var root = tree.GetCompilationUnitRoot();
            if (root == null)
            {
                throw new InvalidOperationException("Source has no root.");
            }

            var node = root.Members.FirstOrDefault(m => m.Kind() == SyntaxKind.NamespaceDeclaration);
            if (node != null)
            {
                node = node.ChildNodes().FirstOrDefault(c => c.IsKind(SyntaxKind.EnumDeclaration)) as MemberDeclarationSyntax;
            }
            else
            {
                node = root.Members.FirstOrDefault(n => n.Kind() == SyntaxKind.EnumDeclaration);
            }
            if (node == null)
            {
                throw new InvalidOperationException("Unable to find enum declaration.");
            }

            if (node.AttributeLists.Count == 0)
            {
                throw new InvalidOperationException("Unable to find [Flags] attribute.");
            }

            var attribute = node.AttributeLists.FirstOrDefault(al => al.Attributes.Any(a => a.Name.GetText().ToString() == "Flags" || a.Name.GetText().ToString() == "FlagsAttribute"));
            if (attribute == null)
            {
                throw new InvalidOperationException("Unable to find [Flags] attribute.");
            }

            var enumMembers = node.ChildNodes().Where(n => n.Kind() == SyntaxKind.EnumMemberDeclaration).Cast<EnumMemberDeclarationSyntax>().ToList();
            var enumValues = new Dictionary<string, int>(StringComparer.InvariantCultureIgnoreCase);
            foreach (var enumMember in enumMembers)
            {
                if (enumMember.EqualsValue is null)
                {
                    continue;
                }
                if (enumMember.EqualsValue.Value is BinaryExpressionSyntax binaryExpression)
                {
                    enumValues.Add(enumMember.Identifier.Text, ParseBinaryExpression(binaryExpression, enumMembers));
                }
                else if (enumMember.EqualsValue.Value is LiteralExpressionSyntax literalExpression)
                {
                    enumValues.Add(enumMember.Identifier.Text, ParseLiteralExpression(literalExpression));
                }
                else if (enumMember.EqualsValue.Value is IdentifierNameSyntax identifierNameSyntax)
                {
                    enumValues.Add(enumMember.Identifier.Text, ParseIdentifierNameExpression(identifierNameSyntax, enumMembers));
                }
            }

            if (enumValues.Count == 0)
            {
                throw new InvalidOperationException("No enum values were found.");
            }

            return enumValues;
        }

        private static int ParseLiteralExpression(LiteralExpressionSyntax literalExpression)
        {
            if (literalExpression.Kind() == SyntaxKind.NumericLiteralExpression)
            {
                string text = literalExpression.GetText().ToString();
                return int.Parse(text);
            }
            else
            {
                throw new InvalidOperationException($"Unexpected literal expression {literalExpression.Kind()}.");
            }
        }

        private static int ParseIdentifierNameExpression(IdentifierNameSyntax identifierNameSyntax, List<EnumMemberDeclarationSyntax> enumMembers)
        {
            var enumDeclaration = enumMembers.FirstOrDefault(e => e.Identifier.Text == identifierNameSyntax.Identifier.Text);
            if (enumDeclaration == null)
            {
                throw new InvalidOperationException($"Unexpected identifier name expression {identifierNameSyntax.Identifier.Text}.");
            }

            if (enumDeclaration.EqualsValue is null)
            {
                throw new InvalidOperationException($"Missing equals value expression for {identifierNameSyntax.Identifier.Text}.");
            }

            if (enumDeclaration.EqualsValue.Value is BinaryExpressionSyntax binaryExpression)
            {
                return ParseBinaryExpression(binaryExpression, enumMembers);
            }
            else if (enumDeclaration.EqualsValue.Value is LiteralExpressionSyntax literalExpression)
            {
                return ParseLiteralExpression(literalExpression);
            }
            else
            {
                throw new InvalidOperationException($"Unexpected equals value expression. {enumDeclaration.EqualsValue.Value.Kind()}.");
            }
        }

        private static int ParseBinaryExpression(BinaryExpressionSyntax binaryExpression, List<EnumMemberDeclarationSyntax> enumMembers)
        {
            int left = 0;
            int right = 0;
            if (binaryExpression.Left is BinaryExpressionSyntax leftBinaryExpression)
            {
                left = ParseBinaryExpression(leftBinaryExpression, enumMembers);
            }
            else if (binaryExpression.Left is LiteralExpressionSyntax leftLiteralExpression)
            {
                left = ParseLiteralExpression(leftLiteralExpression);
            }
            else if (binaryExpression.Left is IdentifierNameSyntax leftIdentifierNameExpression)
            {
                left = ParseIdentifierNameExpression(leftIdentifierNameExpression, enumMembers);
            }
            else
            {
                throw new InvalidOperationException($"Unexpected reft part of binary expression {binaryExpression.Left.Kind()}.");
            }

            if (binaryExpression.Right is BinaryExpressionSyntax rightBinaryExpression)
            {
                right = ParseBinaryExpression(rightBinaryExpression, enumMembers);
            }
            else if (binaryExpression.Right is LiteralExpressionSyntax rightLiteralExpression)
            {
                right = ParseLiteralExpression(rightLiteralExpression);
            }
            else if (binaryExpression.Right is IdentifierNameSyntax rightIdentifierNameExpression)
            {
                right = ParseIdentifierNameExpression(rightIdentifierNameExpression, enumMembers);
            }
            else
            {
                throw new InvalidOperationException($"Unexpected right part of binary expression {binaryExpression.Right.Kind()}.");
            }

            return Evaluate(left, binaryExpression.OperatorToken, right);
        }

        private static int Evaluate(int left, SyntaxToken operatorToken, int right)
        {
            return operatorToken.Kind() switch
            {
                SyntaxKind.LessThanLessThanToken => left << right,
                SyntaxKind.GreaterThanGreaterThanToken => left >> right,
                SyntaxKind.BarToken => left | right,
                SyntaxKind.AmpersandToken => left & right,
                SyntaxKind.CaretToken => left ^ right,
                _ => throw new InvalidOperationException($"Unsupported operator on binary expression {operatorToken.Kind()}."),
            };
        }

        public IDictionary<string, int> ConvertValue(int value)
        {
            if (_enumCache == null)
            {
                throw new InvalidOperationException("No enum values were found.");
            }

            if (value == 0 && _enumCache.ContainsValue(value))
            {
                KeyValuePair<string, int> keyValuePair = _enumCache.FirstOrDefault(e => e.Value == value);
                return new Dictionary<string, int>
                {
                    { keyValuePair.Key, keyValuePair.Value }
                };
            }

            var dictionary = new Dictionary<string, int>();
            foreach (var item in _enumCache)
            {
                if (item.Value != 0 && (item.Value | value) == value)
                {
                    dictionary.Add(item.Key, item.Value);
                }
            }

            return dictionary;
        }
    }
}