Add pattern matching in If Statements

src/VaVare.Tests/Statements/SelectionStatementTests.cs

@@ -1,7 +1,10 @@
-using NUnit.Framework;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using NUnit.Framework;
 using VaVare.Generators.Common;
 using VaVare.Generators.Common.Arguments.ArgumentTypes;
 using VaVare.Generators.Common.BinaryExpressions;
+using VaVare.Generators.Common.Patterns;
 using VaVare.Models.References;
 using VaVare.Statements;
 using Assert = NUnit.Framework.Assert;
@@ -106,5 +109,91 @@ public void If_WhenCreatingAnIfWithBinaryExpressionAndExpressionStatement_Should
             Assert.AreEqual("if(2==3)MyMethod();",
                 conditional.If(new ConditionalBinaryExpression(new ConstantReference(2), new ConstantReference(3), ConditionalStatements.Equal), Statement.Expression.Invoke("MyMethod").AsStatement()).ToString());
         }
+
+        [Test]
+        public void If_ConditionalIsExpression()
+        {
+            var expected = "if(a is string){}".Replace(" ", "");
+            var sut = conditional.If(new ValueArgument("a", false), new ValueArgument("string", false), ConditionalStatements.Is, BodyGenerator.Create());
+
+            Assert.That(sut.ToFullString(), Is.EqualTo(expected));
+        }
+
+        [Test]
+        public void If_DeclarationPattern()
+        {
+            var expected = "if(a is string b){}".Replace(" ", "");
+
+            var declarationPattern = new DeclarationPattern(SyntaxFactory.ParseTypeName("string"), "b");
+            var sut = conditional.If(new ValueArgument("a", false), declarationPattern, BodyGenerator.Create());
+
+            Assert.That(sut.ToFullString(), Is.EqualTo(expected));
+        }
+
+        [Test]
+        public void If_NotTypePattern()
+        {
+            var expected = "if(a is not string){}".Replace(" ", "");
+
+            var typePattern = new TypePattern(SyntaxFactory.ParseTypeName("string"));
+            var pattern = new NotPattern(typePattern);
+            var sut = conditional.If(new ValueArgument("a", false), pattern, BodyGenerator.Create());
+
+            Assert.That(sut.ToFullString(), Is.EqualTo(expected));
+        }
+
+        [Test]
+        public void If_NotConstantPattern()
+        {
+            var expected = "if(a is not 12){}".Replace(" ", "");
+
+            var typePattern = new ConstantPattern(new ValueArgument(12));
+            var pattern = new NotPattern(typePattern);
+            var sut = conditional.If(new ValueArgument("a", false), pattern, BodyGenerator.Create());
+
+            Assert.That(sut.ToFullString(), Is.EqualTo(expected));
+        }
+
+        [Test]
+        public void If_NotAndRelationalPattern()
+        {
+            var expected = "if(a is not 12 and > 15){}".Replace(" ", "");
+
+            var typePattern = new ConstantPattern(new ValueArgument(12));
+            var relationPattern = new RelationalPattern(ConditionalStatements.GreaterThan, new ValueArgument(15));
+            var and = new AndPattern(typePattern, relationPattern);
+            var pattern = new NotPattern(and);
+            var sut = conditional.If(new ValueArgument("a", false), pattern, BodyGenerator.Create());
+
+            Assert.That(sut.ToFullString(), Is.EqualTo(expected));
+        }
+
+        [Test]
+        public void If_NotAndRelationalPatternGreaterEquals()
+        {
+            var expected = "if(a is not 12 and >= 15){}".Replace(" ", "");
+
+            var typePattern = new ConstantPattern(new ValueArgument(12));
+            var relationPattern = new RelationalPattern(ConditionalStatements.GreaterThanOrEqual, new ValueArgument(15));
+            var and = new AndPattern(typePattern, relationPattern);
+            var pattern = new NotPattern(and);
+            var sut = conditional.If(new ValueArgument("a", false), pattern, BodyGenerator.Create());
+
+            Assert.That(sut.ToFullString(), Is.EqualTo(expected));
+        }
+
+        [Test]
+        public void If_NotOrRelationalPatternGreaterEquals()
+        {
+            var expected = "if(a is not 12 or >= 15){}".Replace(" ", "");
+
+            var typePattern = new ConstantPattern(new ValueArgument(12));
+            var relationPattern = new RelationalPattern(ConditionalStatements.GreaterThanOrEqual, new ValueArgument(15));
+            var and = new OrPattern(typePattern, relationPattern);
+            var pattern = new NotPattern(and);
+            var sut = conditional.If(new ValueArgument("a", false), pattern, BodyGenerator.Create());
+
+            Assert.That(sut.ToFullString(), Is.EqualTo(expected));
+        }
     }
 }

src/VaVare/Enums.cs

@@ -36,6 +36,11 @@ public enum ConditionalStatements
         /// Generate with a less than or equal conditional statement: <c>"&lt;="</c>.
         /// </summary>
         LessThanOrEqual,
+
+        /// <summary>
+        /// Generate with an is statement: <c>"is"</c>.
+        /// </summary>
+        Is,
     }
 
     /// <summary>

src/VaVare/Factories/ConditionalFactory.cs

@@ -21,6 +21,29 @@ public static SyntaxKind GetSyntaxKind(ConditionalStatements conditional)
                     return SyntaxKind.LessThanExpression;
                 case ConditionalStatements.LessThanOrEqual:
                     return SyntaxKind.LessThanOrEqualExpression;
+                case ConditionalStatements.Is:
+                    return SyntaxKind.IsExpression;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(conditional), conditional, null);
+            }
+        }
+
+        public static SyntaxKind GetSyntaxKindToken(ConditionalStatements conditional)
+        {
+            switch (conditional)
+            {
+                case ConditionalStatements.Equal:
+                    return SyntaxKind.EqualsToken;
+                case ConditionalStatements.NotEqual:
+                    return SyntaxKind.ExclamationEqualsToken;
+                case ConditionalStatements.GreaterThan:
+                    return SyntaxKind.GreaterThanToken;
+                case ConditionalStatements.GreaterThanOrEqual:
+                    return SyntaxKind.GreaterThanEqualsToken;
+                case ConditionalStatements.LessThan:
+                    return SyntaxKind.LessThanToken;
+                case ConditionalStatements.LessThanOrEqual:
+                    return SyntaxKind.LessThanEqualsToken;
                 default:
                     throw new ArgumentOutOfRangeException(nameof(conditional), conditional, null);
             }

src/VaVare/Generators/Common/PatternExpressions/IPatternExpression.cs

@@ -0,0 +1,13 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace VaVare.Generators.Common.PatternExpressions
+{
+    public interface IPatternExpression
+    {
+        /// <summary>
+        /// Get the generated pattern expression.
+        /// </summary>
+        /// <returns>The generated pattern expression.</returns>
+        ExpressionSyntax GetPatternExpression();
+    }
+}

src/VaVare/Generators/Common/PatternExpressions/IsPatternExpression.cs

@@ -0,0 +1,23 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+
+namespace VaVare.Generators.Common.PatternExpressions
+{
+    public class IsPatternExpression : IPatternExpression
+    {
+        private readonly ExpressionSyntax _expressionSyntax;
+        private readonly PatternSyntax _patternSyntax;
+
+        public IsPatternExpression(ExpressionSyntax expressionSyntax, PatternSyntax patternSyntax)
+        {
+            _expressionSyntax = expressionSyntax;
+            _patternSyntax = patternSyntax;
+        }
+
+        public ExpressionSyntax GetPatternExpression()
+        {
+            return IsPatternExpression(_expressionSyntax, _patternSyntax);
+        }
+    }
+}

src/VaVare/Generators/Common/Patterns/AndPattern.cs

@@ -0,0 +1,30 @@
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+
+namespace VaVare.Generators.Common.Patterns
+{
+    public class AndPattern : Pattern
+    {
+        private readonly PatternSyntax _left;
+        private readonly PatternSyntax _right;
+
+        public AndPattern(PatternSyntax left, PatternSyntax right)
+        {
+            _left = left;
+            _right = right;
+        }
+
+        public AndPattern(Pattern left, Pattern right)
+        {
+            _left = left.GetPatternSyntax();
+            _right = right.GetPatternSyntax();
+        }
+
+        public override PatternSyntax GetPatternSyntax()
+        {
+            return BinaryPattern(SyntaxKind.AndPattern, _left, _right);
+        }
+    }
+}

src/VaVare/Generators/Common/Patterns/ConstantPattern.cs

@@ -0,0 +1,26 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using VaVare.Generators.Common.Arguments.ArgumentTypes;
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+
+namespace VaVare.Generators.Common.Patterns
+{
+    public class ConstantPattern : Pattern
+    {
+        private readonly ExpressionSyntax _expressionSyntax;
+
+        public ConstantPattern(ExpressionSyntax expression)
+        {
+            _expressionSyntax = expression;
+        }
+
+        public ConstantPattern(IArgument argument)
+        {
+            _expressionSyntax = argument.GetArgumentSyntax().Expression;
+        }
+
+        public override PatternSyntax GetPatternSyntax()
+        {
+            return ConstantPattern(_expressionSyntax);
+        }
+    }
+}

src/VaVare/Generators/Common/Patterns/DeclarationPattern.cs

@@ -0,0 +1,37 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using VaVare.Factories;
+using VaVare.Generators.Common.Arguments.ArgumentTypes;
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+
+namespace VaVare.Generators.Common.Patterns
+{
+    public class DeclarationPattern : Pattern
+    {
+        private readonly TypeSyntax _typeSyntax;
+        private readonly VariableDesignationSyntax _variableDesignationSyntax;
+
+        public DeclarationPattern(TypeSyntax syntaxToken, VariableDesignationSyntax expressionSyntax)
+        {
+            _typeSyntax = syntaxToken;
+            _variableDesignationSyntax = expressionSyntax;
+        }
+
+        public DeclarationPattern(TypeSyntax syntaxToken, string identifier)
+        {
+            _typeSyntax = syntaxToken;
+            _variableDesignationSyntax = SingleVariableDesignation(Identifier(identifier));
+        }
+
+        public DeclarationPattern(TypeSyntax syntaxToken, SyntaxToken identifier)
+        {
+            _typeSyntax = syntaxToken;
+            _variableDesignationSyntax = SingleVariableDesignation(identifier);
+        }
+
+        public override PatternSyntax GetPatternSyntax()
+        {
+            return DeclarationPattern(_typeSyntax, _variableDesignationSyntax);
+        }
+    }
+}

src/VaVare/Generators/Common/Patterns/DiscardPattern.cs

@@ -0,0 +1,13 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+
+namespace VaVare.Generators.Common.Patterns
+{
+    public class DiscardPattern : Pattern
+    {
+        public override PatternSyntax GetPatternSyntax()
+        {
+            return DiscardPattern();
+        }
+    }
+}

src/VaVare/Generators/Common/Patterns/IPattern.cs

@@ -0,0 +1,9 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace VaVare.Generators.Common.Patterns
+{
+    public interface IPattern
+    {
+        PatternSyntax GetPatternSyntax();
+    }
+}

src/VaVare/Generators/Common/Patterns/NotPattern.cs

@@ -0,0 +1,28 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using VaVare.Factories;
+using VaVare.Generators.Common.Arguments.ArgumentTypes;
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+
+namespace VaVare.Generators.Common.Patterns
+{
+    public class NotPattern : Pattern
+    {
+        private readonly PatternSyntax _pattern;
+
+        public NotPattern(PatternSyntax pattern)
+        {
+            _pattern = pattern;
+        }
+
+        public NotPattern(Pattern pattern)
+        {
+            _pattern = pattern.GetPatternSyntax();
+        }
+
+        public override PatternSyntax GetPatternSyntax()
+        {
+            return UnaryPattern(_pattern);
+        }
+    }
+}

src/VaVare/Generators/Common/Patterns/OrPattern.cs

@@ -0,0 +1,30 @@
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
+
+namespace VaVare.Generators.Common.Patterns
+{
+    public class OrPattern : Pattern
+    {
+        private readonly PatternSyntax _left;
+        private readonly PatternSyntax _right;
+
+        public OrPattern(PatternSyntax left, PatternSyntax right)
+        {
+            _left = left;
+            _right = right;
+        }
+
+        public OrPattern(Pattern left, Pattern right)
+        {
+            _left = left.GetPatternSyntax();
+            _right = right.GetPatternSyntax();
+        }
+
+        public override PatternSyntax GetPatternSyntax()
+        {
+            return BinaryPattern(SyntaxKind.OrPattern, _left, _right);
+        }
+    }
+}

src/VaVare/Generators/Common/Patterns/Pattern.cs

@@ -0,0 +1,19 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace VaVare.Generators.Common.Patterns
+{
+    /// <summary>
+    /// Provides the base class from which the classes that represent pattern derived.
+    /// </summary>
+    public abstract class Pattern : IPattern
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Pattern"/> class.
+        /// </summary>
+        protected Pattern()
+        {
+        }
+
+        public abstract PatternSyntax GetPatternSyntax();
+    }
+}