C#: Implement extractor support for unsigned right shift.

Author: michaelnebel

csharp/extractor/Semmle.Extraction.CSharp/Entities/Expression.cs

@@ -240,7 +240,7 @@ public void OperatorCall(TextWriter trapFile, ExpressionSyntax node)
                 var callType = GetCallType(Context, node);
                 if (callType == CallType.Dynamic)
                 {
-                    UserOperator.OperatorSymbol(method.Name, out var operatorName);
+                    UserOperator.TryGetOperatorSymbol(method.Name, out var operatorName);
                     trapFile.dynamic_member_name(this, operatorName);
                     return;
                 }

csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Assignment.cs

@@ -71,6 +71,8 @@ private static ExprKind GetAssignmentOperation(Context cx, AssignmentExpressionS
                     return ExprKind.ASSIGN_LSHIFT;
                 case SyntaxKind.GreaterThanGreaterThanEqualsToken:
                     return ExprKind.ASSIGN_RSHIFT;
+                case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken:
+                    return ExprKind.ASSIGN_URSHIFT;
                 case SyntaxKind.QuestionQuestionEqualsToken:
                     return ExprKind.ASSIGN_COALESCE;
                 default:
@@ -141,6 +143,8 @@ private ExprKind? OperatorKind
                         return ExprKind.REM;
                     case ExprKind.ASSIGN_RSHIFT:
                         return ExprKind.RSHIFT;
+                    case ExprKind.ASSIGN_URSHIFT:
+                        return ExprKind.URSHIFT;
                     case ExprKind.ASSIGN_SUB:
                         return ExprKind.SUB;
                     case ExprKind.ASSIGN_XOR:

csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Binary.cs

@@ -50,6 +50,7 @@ private static ExprKind GetBinaryTokenKind(Context cx, BinaryExpressionSyntax no
                 case SyntaxKind.BarBarToken: return ExprKind.LOG_OR;
                 case SyntaxKind.GreaterThanEqualsToken: return ExprKind.GE;
                 case SyntaxKind.GreaterThanGreaterThanToken: return ExprKind.RSHIFT;
+                case SyntaxKind.GreaterThanGreaterThanGreaterThanToken: return ExprKind.URSHIFT;
                 case SyntaxKind.LessThanLessThanToken: return ExprKind.LSHIFT;
                 case SyntaxKind.CaretToken: return ExprKind.BIT_XOR;
                 case SyntaxKind.QuestionQuestionToken: return ExprKind.NULL_COALESCING;

csharp/extractor/Semmle.Extraction.CSharp/Entities/Expressions/Factory.cs

@@ -38,6 +38,7 @@ internal static Expression Create(ExpressionNodeInfo info)
                     case SyntaxKind.IsExpression:
                     case SyntaxKind.AsExpression:
                     case SyntaxKind.RightShiftExpression:
+                    case SyntaxKind.UnsignedRightShiftExpression:
                     case SyntaxKind.LeftShiftExpression:
                     case SyntaxKind.ExclusiveOrExpression:
                     case SyntaxKind.CoalesceExpression:
@@ -76,6 +77,7 @@ internal static Expression Create(ExpressionNodeInfo info)
                     case SyntaxKind.ExclusiveOrAssignmentExpression:
                     case SyntaxKind.LeftShiftAssignmentExpression:
                     case SyntaxKind.RightShiftAssignmentExpression:
+                    case SyntaxKind.UnsignedRightShiftAssignmentExpression:
                     case SyntaxKind.DivideAssignmentExpression:
                     case SyntaxKind.ModuloAssignmentExpression:
                     case SyntaxKind.CoalesceAssignmentExpression:

csharp/extractor/Semmle.Extraction.CSharp/Entities/UserOperator.cs

@@ -61,8 +61,7 @@ private bool IsImplicitOperator(out ITypeSymbol containingType)
             containingType = Symbol.ContainingType;
             if (containingType is not null)
             {
-                var containingNamedType = containingType as INamedTypeSymbol;
-                return containingNamedType is null ||
+                return containingType is not INamedTypeSymbol containingNamedType ||
                     !containingNamedType.GetMembers(Symbol.Name).Contains(Symbol);
             }
 
@@ -83,7 +82,7 @@ private bool IsImplicitOperator(out ITypeSymbol containingType)
         /// </summary>
         /// <param name="methodName">The method name.</param>
         /// <param name="operatorName">The converted operator name.</param>
-        public static bool OperatorSymbol(string methodName, out string operatorName)
+        public static bool TryGetOperatorSymbol(string methodName, out string operatorName)
         {
             var success = true;
             switch (methodName)
@@ -147,6 +146,9 @@ public static bool OperatorSymbol(string methodName, out string operatorName)
                 case "op_RightShift":
                     operatorName = ">>";
                     break;
+                case "op_UnsignedRightShift":
+                    operatorName = ">>>";
+                    break;
                 case "op_LeftShift":
                     operatorName = "<<";
                     break;
@@ -166,7 +168,7 @@ public static bool OperatorSymbol(string methodName, out string operatorName)
                     var match = Regex.Match(methodName, "^op_Checked(.*)$");
                     if (match.Success)
                     {
-                        OperatorSymbol("op_" + match.Groups[1], out var uncheckedName);
+                        TryGetOperatorSymbol("op_" + match.Groups[1], out var uncheckedName);
                         operatorName = "checked " + uncheckedName;
                         break;
                     }
@@ -190,7 +192,7 @@ private static string OperatorSymbol(Context cx, IMethodSymbol method)
                 return OperatorSymbol(cx, method.ExplicitInterfaceImplementations.First());
 
             var methodName = method.Name;
-            if (!OperatorSymbol(methodName, out var result))
+            if (!TryGetOperatorSymbol(methodName, out var result))
                 cx.ModelError(method, $"Unhandled operator name in OperatorSymbol(): '{methodName}'");
             return result;
         }