Start of better handling of #if directives

closes #404

Src/CSharpier.Tests/ConditionalServiceTests.cs

@@ -0,0 +1,103 @@
+using System;
+using System.Linq;
+using FluentAssertions;
+using NUnit.Framework;
+
+namespace CSharpier.Tests;
+
+[TestFixture]
+public class ConditionalServiceTests
+{
+ [Test]
+ public void GetSymbolSets_Should_Handle_Basic_If()
+ {
+ RunTest(
+ @"#if DEBUG
+public class Tester { }
+#endif
+",
+ new[] { "DEBUG" }
+ );
+ }
+
+ [Test]
+ public void GetSymbolSets_Should_Handle_And()
+ {
+ RunTest(
+ @"#if ONE && TWO
+public class Tester { }
+#endif
+",
+ new[] { "DEBUG" }
+ );
+ }
+
+ [Test]
+ public void GetSymbolSets_Should_Handle_Or()
+ {
+ RunTest(
+ @"#if ONE || TWO
+public class Tester { }
+#endif
+",
+ new[] { "DEBUG" }
+ );
+ }
+
+ [Test]
+ public void GetSymbolSets_Should_Handle_Basic_Not_If()
+ {
+ RunTest(
+ @"#if !DEBUG
+public class Tester { }
+#endif
+",
+ Array.Empty<string>()
+ );
+ }
+
+ [Test]
+ public void GetSymbolSets_Should_Handle_Basic_If_With_Else()
+ {
+ RunTest(
+ @"#if DEBUG
+public class Tester { }
+#else
+public class Tester2 { }
+#endif
+",
+ new[] { "DEBUG" },
+ Array.Empty<string>()
+ );
+ }
+
+ [Test]
+ public void GetSymbolSets_Should_Handle_Basic_If_With_ElseIf()
+ {
+ RunTest(
+ @"#if ONE
+public class Tester { }
+#elif TWO
+public class Tester2 { }
+#endif
+",
+ new[] { "ONE" },
+ new[] { "TWO" }
+ );
+ }
+
+ private void RunTest(string code, params string[][] symbolSets)
+ {
+ var result = ConditionalService.GetSymbolSets(code);
+
+ result.Should().HaveCount(symbolSets.Length);
+ for (var x = 0; x < symbolSets.Length; x++)
+ {
+ result[x].Should().HaveCount(symbolSets[x].Length);
+ foreach (var symbol in symbolSets[x])
+ {
+ result[x].Should().Contain(symbol);
+ }
+ }
+ }
+}

Src/CSharpier/ConditionalService.cs

@@ -0,0 +1,111 @@
+namespace CSharpier;
+
+public class ConditionalService
+{
+ // TODO this can probably take a SyntaxTree to make it more efficient
+ public static List<string[]> GetSymbolSets(string code)
+ {
+ var tree = CSharpSyntaxTree.ParseText(code);
+
+ var customWalker = new CustomWalker();
+ customWalker.Visit(tree.GetRoot());
+
+ return customWalker.GetSymbolSets();
+ }
+
+ private class CustomWalker : CSharpSyntaxWalker
+ {
+ public CustomWalker() : base(SyntaxWalkerDepth.Trivia) { }
+
+ private List<string[]> symbolSets = new();
+
+ public List<string[]> GetSymbolSets()
+ {
+ return this.symbolSets;
+ }
+
+ // TODO test with real code!!!
+ // TODO could we optimize even more? do we need to visit trailing trivia?
+ public override void VisitLeadingTrivia(SyntaxToken token)
+ {
+ if (token.HasLeadingTrivia)
+ {
+ foreach (var tr in token.LeadingTrivia)
+ {
+ if (
+ tr.RawSyntaxKind()
+ is SyntaxKind.IfDirectiveTrivia
+ or SyntaxKind.ElifDirectiveTrivia
+ or SyntaxKind.ElseDirectiveTrivia
+ or SyntaxKind.EndIfDirectiveTrivia
+ )
+ {
+ this.Visit((CSharpSyntaxNode)tr.GetStructure()!);
+ }
+ }
+ }
+ }
+
+ public override void VisitIfDirectiveTrivia(IfDirectiveTriviaSyntax node)
+ {
+ DoThing(node.Condition);
+ }
+
+ public override void VisitElifDirectiveTrivia(ElifDirectiveTriviaSyntax node)
+ {
+ DoThing(node.Condition);
+ }
+
+ // TODO make use of the walker itself for this?
+ // TODO ( )
+ // TODO ! !
+ // TODO mix of && and ||
+ // TODO nested ifs
+ // TODO ideally we narrow down to the best set of symbols to limit the formatting passes
+ private void DoThing(ExpressionSyntax expression)
+ {
+ if (expression is IdentifierNameSyntax identifierNameSyntax)
+ {
+ this.symbolSets.Add(new[] { identifierNameSyntax.Identifier.ToString() });
+ }
+ else if (expression is PrefixUnaryExpressionSyntax prefixUnaryExpressionSyntax)
+ {
+ if (
+ prefixUnaryExpressionSyntax.OperatorToken.RawSyntaxKind()
+ is SyntaxKind.ExclamationToken
+ )
+ {
+ if (
+ prefixUnaryExpressionSyntax.Operand
+ is IdentifierNameSyntax identifierNameSyntax2
+ )
+ {
+ this.symbolSets.Add(Array.Empty<string>());
+ }
+ }
+ else
+ {
+ Console.WriteLine("Can't handle " + prefixUnaryExpressionSyntax.OperatorToken);
+ }
+ }
+ else if (expression is BinaryExpressionSyntax binaryExpressionSyntax)
+ {
+ throw new Exception("BINARY EXPRESSIONS!");
+ }
+ else
+ {
+ Console.WriteLine("Can't handle " + expression.GetType());
+ }
+ }
+
+ public override void VisitElseDirectiveTrivia(ElseDirectiveTriviaSyntax node)
+ {
+ // TODO
+ }
+
+ public override void VisitEndIfDirectiveTrivia(EndIfDirectiveTriviaSyntax node)
+ {
+ // TODO
+ }
+ }
+}