Old SE: Handle unsupported syntax gracefully

analyzers/src/SonarAnalyzer.CFG/Sonar/CSharpControlFlowGraphBuilder.cs

@@ -1286,6 +1286,36 @@ private Block BuildPatternExpression(PatternSyntaxWrapper patternSyntaxWrapper,
                 currentBlock.ReversedInstructions.Add(patternSyntaxWrapper);
                 return currentBlock;
             }
+            else if (ParenthesizedPatternSyntaxWrapper.IsInstance(patternSyntaxWrapper))
+            {
+                var parenthesized = (ParenthesizedPatternSyntaxWrapper)patternSyntaxWrapper;
+                return BuildPatternExpression(parenthesized.Pattern, currentBlock);
+            }
+            else if (BinaryPatternSyntaxWrapper.IsInstance(patternSyntaxWrapper))
+            {
+                // Unsupported
+                return currentBlock;
+            }
+            else if (UnaryPatternSyntaxWrapper.IsInstance(patternSyntaxWrapper))
+            {
+                // Unsupported
+                return currentBlock;
+            }
+            else if (VarPatternSyntaxWrapper.IsInstance(patternSyntaxWrapper))
+            {
+                // Unsupported
+                return currentBlock;
+            }
+            else if (RelationalPatternSyntaxWrapper.IsInstance(patternSyntaxWrapper))
+            {
+                // Unsupported
+                return currentBlock;
+            }
+            else if (ListPatternSyntaxWrapper.IsInstance(patternSyntaxWrapper))
+            {
+                // Unsupported
+                return currentBlock;
+            }
 
             throw new NotSupportedException($"{patternSyntaxWrapper.SyntaxNode.Kind()}");
         }

analyzers/src/SonarAnalyzer.CSharp/SymbolicExecution/Sonar/SonarExplodedGraph.cs

@@ -515,7 +515,14 @@ protected override void VisitInstruction(ExplodedGraphNode node)
                     }
                     else
                     {
-                        throw new NotSupportedException($"{instruction.Kind()}");
+                        // Unsupported patten kinds:
+                        // * ParenthesizedPattern
+                        // * BinaryPattern
+                        // * UnaryPattern
+                        // * VarPattern
+                        // * RelationalPattern
+                        // * ListPattern
+                        // * SlicePattern
                     }
                     break;
 

analyzers/tests/SonarAnalyzer.UnitTest/SymbolicExecution/Sonar/SonarExplodedGraphTest.cs

@@ -28,7 +28,6 @@
 using SonarAnalyzer.LiveVariableAnalysis.CSharp;
 using SonarAnalyzer.SymbolicExecution.Constraints;
 using SonarAnalyzer.SymbolicExecution.Sonar;
-using SonarAnalyzer.SymbolicExecution.Sonar.Constraints;
 using SonarAnalyzer.UnitTest.CFG.Sonar;
 using SonarAnalyzer.UnitTest.Helpers;
 
@@ -901,6 +900,249 @@ public void ExplodedGraph_IsPattern_WithPositionalPattern()
             context.WalkWithInstructions(4);
         }
 
+        [TestMethod]
+        public void ExplodedGraph_IsPattern_Parentesized()
+        {
+            const string testInput = @"var x = obj is (string s);";
+
+            var context = new ExplodedGraphContext(testInput);
+            var sSymbol = context.GetSymbol("s", ExplodedGraphContext.SymbolType.Declaration);
+
+            context.ExplodedGraph.InstructionProcessed += (sender, args) =>
+            {
+                var instruction = args.Instruction.ToString();
+
+                switch (instruction)
+                {
+                    case "obj":
+                        args.ProgramState.GetSymbolValue(sSymbol).Should().BeNull();
+                        break;
+
+                    case "obj is (string s)":
+                        args.ProgramState.GetSymbolValue(sSymbol).Should().BeNull();
+                        args.ProgramState.HasValue.Should().BeTrue();
+                        break;
+
+                    case "x = obj is (string s)":
+                        args.ProgramState.GetSymbolValue(sSymbol).Should().BeNull();
+                        args.ProgramState.HasValue.Should().BeFalse();
+                        break;
+
+                    default:
+                        throw new NotImplementedException();
+                }
+            };
+
+            context.WalkWithInstructions(3);
+        }
+
+        [TestMethod]
+        public void ExplodedGraph_IsPattern_OrPattern_NotSupported()
+        {
+            const string testInput = "var x = obj is 1 or 2;";
+
+            var context = new ExplodedGraphContext(testInput);
+            context.ExplodedGraph.InstructionProcessed += (sender, args) =>
+            {
+                var instruction = args.Instruction.ToString();
+
+                switch (instruction)
+                {
+                    case "obj":
+                    case "obj is 1 or 2":
+                    case "x = obj is 1 or 2":
+                        break;
+                    default:
+                        throw new NotImplementedException();
+                }
+            };
+
+            context.WalkWithInstructions(3);
+        }
+
+        [TestMethod]
+        public void ExplodedGraph_IsPattern_AndPattern_NotSupported()
+        {
+            const string testInput = "var x = obj is 1 and 2;";
+
+            var context = new ExplodedGraphContext(testInput);
+            context.ExplodedGraph.InstructionProcessed += (sender, args) =>
+            {
+                var instruction = args.Instruction.ToString();
+
+                switch (instruction)
+                {
+                    case "obj":
+                    case "obj is 1 and 2":
+                    case "x = obj is 1 and 2":
+                        break;
+                    default:
+                        throw new NotImplementedException();
+                }
+            };
+
+            context.WalkWithInstructions(3);
+        }
+
+        [TestMethod]
+        public void ExplodedGraph_IsPattern_NotPattern_NotSupported()
+        {
+            const string testInput = "var x = obj is not 1;";
+
+            var context = new ExplodedGraphContext(testInput);
+            context.ExplodedGraph.InstructionProcessed += (sender, args) =>
+            {
+                var instruction = args.Instruction.ToString();
+
+                switch (instruction)
+                {
+                    case "obj":
+                    case "obj is not 1":
+                    case "x = obj is not 1":
+                        break;
+                    default:
+                        throw new NotImplementedException();
+                }
+            };
+
+            context.WalkWithInstructions(3);
+        }
+
+        [TestMethod]
+        public void ExplodedGraph_IsPattern_VarPattern_NotSupported()
+        {
+            const string testInput = """
+                var x = obj is var i;
+                i++;
+                """;
+
+            var context = new ExplodedGraphContext(testInput);
+            var symbolNotFound = () => context.GetSymbol("o", ExplodedGraphContext.SymbolType.Declaration);
+            symbolNotFound.Should().Throw<InvalidOperationException>("var pattern is not supported");
+
+            context.ExplodedGraph.InstructionProcessed += (sender, args) =>
+            {
+                var instruction = args.Instruction.ToString();
+
+                switch (instruction)
+                {
+                    case "obj":
+                    case "obj is var i":
+                    case "x = obj is var i":
+                    case "i":
+                    case "i++":
+                        break;
+
+                    default:
+                        throw new NotImplementedException(instruction);
+                }
+            };
+            context.WalkWithInstructions(5);
+        }
+
+        [TestMethod]
+        public void ExplodedGraph_IsPattern_RelationalPattern_NotSupported()
+        {
+            const string testInput = """
+                var x = obj is > 5;
+                """;
+
+            var context = new ExplodedGraphContext(testInput);
+
+            context.ExplodedGraph.InstructionProcessed += (sender, args) =>
+            {
+                var instruction = args.Instruction.ToString();
+
+                switch (instruction)
+                {
+                    case "obj":
+                    case "obj is > 5":
+                    case "x = obj is > 5":
+                        break;
+                    default:
+                        throw new NotImplementedException(instruction);
+                }
+            };
+            context.WalkWithInstructions(3);
+        }
+
+        [TestMethod]
+        public void ExplodedGraph_IsPattern_ListPattern_NotSupported()
+        {
+            const string testInput = """
+                var x = new object[] { } is [] empty;
+                empty.ToString();
+                """;
+
+            var context = new ExplodedGraphContext(testInput);
+            var emptySymbol = context.GetSymbol("empty", ExplodedGraphContext.SymbolType.Declaration);
+
+            context.ExplodedGraph.InstructionProcessed += (sender, args) =>
+            {
+                var instruction = args.Instruction.ToString();
+
+                switch (instruction)
+                {
+                    case "":
+                        args.ProgramState.GetSymbolValue(emptySymbol).Should().BeNull();
+                        break;
+                    case "object[]":
+                        args.ProgramState.GetSymbolValue(emptySymbol).Should().BeNull();
+                        break;
+                    case "new object[] { }":
+                        args.ProgramState.GetSymbolValue(emptySymbol).Should().BeNull();
+                        break;
+                    case "{ }":
+                        args.ProgramState.GetSymbolValue(emptySymbol).Should().BeNull();
+                        break;
+                    case "new object[] { } is [] empty":
+                        args.ProgramState.GetSymbolValue(emptySymbol).Should().BeNull();
+                        break;
+                    case "x = new object[] { } is [] empty":
+                        args.ProgramState.GetSymbolValue(emptySymbol).Should().BeNull();
+                        break;
+                    case "empty":
+                        args.ProgramState.GetSymbolValue(emptySymbol).Should().BeNull();
+                        break;
+                    case "empty.ToString":
+                        args.ProgramState.GetSymbolValue(emptySymbol).Should().BeNull();
+                        break;
+                    case "empty.ToString()":
+                        args.ProgramState.GetSymbolValue(emptySymbol).Should().BeNull();
+                        break;
+                    default:
+                        throw new NotImplementedException(instruction);
+                }
+            };
+            context.WalkWithInstructions(9);
+        }
+
+        [TestMethod]
+        public void ExplodedGraph_SwitchExpression_TypePattern_NotSupported()
+        {
+            const string testInput = """
+                var x = new object() switch { Exception => true };
+                """;
+
+            var context = new ExplodedGraphContext(testInput);
+
+            context.ExplodedGraph.InstructionProcessed += (sender, args) =>
+            {
+                var instruction = args.Instruction.ToString();
+
+                switch (instruction)
+                {
+                    case "Exception":
+                    case "true":
+                    case "x = new object() switch { Exception => true }":
+                        break;
+                    default:
+                        throw new NotImplementedException(instruction);
+                }
+            };
+            context.WalkWithInstructions(3);
+        }
+
         [TestMethod]
         public void ExplodedGraph_SwitchExpressionVisit()
         {