Merge pull request #4789 from tamasvajk/feature/csharp9-relational-pattern2

C#: Relational patterns

Author: tamasvajk

csharp/change-notes/2021-01-15-Relational-pattern.md

@@ -0,0 +1,3 @@
+lgtm,codescanning
+* The `RelationalPatternExpr` and its 4 sub class have been added to support C# 9
+relational `<`, `>`, `<=`, and `>=` patterns.

csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Patterns/Pattern.cs

@@ -45,6 +45,9 @@ internal static Expression Create(Context cx, PatternSyntax syntax, IExpressionP
                 case RecursivePatternSyntax recPattern:
                     return new RecursivePattern(cx, recPattern, parent, child);
 
+                case RelationalPatternSyntax relPattern:
+                    return new RelationalPattern(cx, relPattern, parent, child);
+
                 case VarPatternSyntax varPattern:
                     switch (varPattern.Designation)
                     {

csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Patterns/RecursivePattern.cs

@@ -15,7 +15,6 @@ internal class RecursivePattern : Expression
         /// <param name="syntax">The syntax node of the recursive pattern.</param>
         /// <param name="parent">The parent pattern/expression.</param>
         /// <param name="child">The child index of this pattern.</param>
-        /// <param name="isTopLevel">If this pattern is in the top level of a case/is. In that case, the variable and type access are populated elsewhere.</param>
         public RecursivePattern(Context cx, RecursivePatternSyntax syntax, IExpressionParentEntity parent, int child) :
             base(new ExpressionInfo(cx, null, cx.Create(syntax.GetLocation()), ExprKind.RECURSIVE_PATTERN, parent, child, false, null))
         {

csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Patterns/RelationalPattern.cs

@@ -0,0 +1,29 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.CSharp;
+using Semmle.Extraction.Kinds;
+using Semmle.Extraction.Entities;
+
+namespace Semmle.Extraction.CSharp.Entities.Expressions
+{
+    internal class RelationalPattern : Expression
+    {
+        public RelationalPattern(Context cx, RelationalPatternSyntax syntax, IExpressionParentEntity parent, int child) :
+             base(new ExpressionInfo(cx, NullType.Create(cx), cx.Create(syntax.GetLocation()), GetKind(syntax.OperatorToken), parent, child, false, null))
+        {
+            Expression.Create(cx, syntax.Expression, this, 0);
+        }
+
+        private static ExprKind GetKind(SyntaxToken operatorToken)
+        {
+            return operatorToken.Kind() switch
+            {
+                SyntaxKind.LessThanEqualsToken => ExprKind.LE_PATTERN,
+                SyntaxKind.GreaterThanEqualsToken => ExprKind.GE_PATTERN,
+                SyntaxKind.LessThanToken => ExprKind.LT_PATTERN,
+                SyntaxKind.GreaterThanToken => ExprKind.GT_PATTERN,
+                _ => throw new InternalError(operatorToken.Parent, $"Relation pattern with operator token '{operatorToken.Kind()}' is not supported."),
+            };
+        }
+    }
+}

csharp/extractor/Semmle.Extraction.CSharp/Kinds/ExprKind.cs

@@ -116,6 +116,10 @@ public enum ExprKind
         ASSIGN_COALESCE = 119,
         SUPPRESS_NULLABLE_WARNING = 120,
         NAMESPACE_ACCESS = 121,
+        LT_PATTERN = 122,
+        GT_PATTERN = 123,
+        LE_PATTERN = 124,
+        GE_PATTERN = 125,
         NOT_PATTERN = 126
     }
 }

csharp/ql/src/semmle/code/csharp/exprs/Expr.qll

@@ -345,6 +345,45 @@ class ConstantPatternExpr extends PatternExpr {
   override string getAPrimaryQlClass() { result = "ConstantPatternExpr" }
 }
 
+/** A relational pattern, for example `>1` in `x is >1`. */
+class RelationalPatternExpr extends PatternExpr, @relational_pattern_expr {
+  /** Gets the name of the operator in this pattern. */
+  string getOperator() { none() }
+
+  /** Gets the expression of this relational pattern. */
+  Expr getExpr() { result = this.getChild(0) }
+
+  override string toString() { result = getOperator() + " ..." }
+}
+
+/** A less-than pattern, for example `< 10` in `x is < 10`. */
+class LTPattern extends RelationalPatternExpr, @lt_pattern_expr {
+  override string getOperator() { result = "<" }
+
+  override string getAPrimaryQlClass() { result = "LTPattern" }
+}
+
+/** A greater-than pattern, for example `> 10` in `x is > 10`. */
+class GTPattern extends RelationalPatternExpr, @gt_pattern_expr {
+  override string getOperator() { result = ">" }
+
+  override string getAPrimaryQlClass() { result = "GTPattern" }
+}
+
+/** A less-than or equals pattern, for example `<= 10` in `x is <= 10`. */
+class LEPattern extends RelationalPatternExpr, @le_pattern_expr {
+  override string getOperator() { result = "<=" }
+
+  override string getAPrimaryQlClass() { result = "LEPattern" }
+}
+
+/** A greater-than or equals pattern, for example `>= 10` in `x is >= 10` */
+class GEPattern extends RelationalPatternExpr, @ge_pattern_expr {
+  override string getOperator() { result = ">=" }
+
+  override string getAPrimaryQlClass() { result = "GEPattern" }
+}
+
 /**
  * A type pattern, for example `string` in `x is string`, `string s` in
  * `x is string s`, or `string _` in `x is string _`.

csharp/ql/src/semmlecode.csharp.dbscheme

@@ -1010,13 +1010,18 @@ case @expr.kind of
 | 120 = @suppress_nullable_warning_expr
 | 121 = @namespace_access_expr
 /* C# 9.0 */
+| 122 = @lt_pattern_expr
+| 123 = @gt_pattern_expr
+| 124 = @le_pattern_expr
+| 125 = @ge_pattern_expr
 | 126 = @not_pattern_expr
 ;
 
 @switch = @switch_stmt | @switch_expr;
 @case = @case_stmt | @switch_case_expr;
 @pattern_match = @case | @is_expr;
 @unary_pattern_expr = @not_pattern_expr;
+@relational_pattern_expr = @gt_pattern_expr | @lt_pattern_expr | @ge_pattern_expr | @le_pattern_expr;
 
 @integer_literal_expr = @int_literal_expr | @long_literal_expr | @uint_literal_expr | @ulong_literal_expr;
 @real_literal_expr = @float_literal_expr | @double_literal_expr | @decimal_literal_expr;