FIXUP of the extractor implementation.

Author: michaelnebel

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

@@ -22,15 +22,7 @@ public static Assignment Create(ExpressionNodeInfo info)
 
         protected override void PopulateExpression(TextWriter trapFile)
         {
-            var operatorKind = OperatorKind;
-            // TODO: THIS CHECK CAN BE SIMPLIFIED - As we now always consider this to be an operator invocation.
-            if (operatorKind.HasValue)
-            {
-                Create(Context, Syntax.Left, this, 0);
-                Create(Context, Syntax.Right, this, 1);
-                OperatorCall(trapFile, Syntax);
-            }
-            else
+            if (Kind == ExprKind.SIMPLE_ASSIGN || Kind == ExprKind.REMOVE_EVENT || Kind == ExprKind.ADD_EVENT)
             {
                 Create(Context, Syntax.Left, this, 1);
                 Create(Context, Syntax.Right, this, 0);
@@ -40,6 +32,12 @@ protected override void PopulateExpression(TextWriter trapFile)
                     OperatorCall(trapFile, Syntax);
                 }
             }
+            else
+            {
+                Create(Context, Syntax.Left, this, 0);
+                Create(Context, Syntax.Right, this, 1);
+                OperatorCall(trapFile, Syntax);
+            }
         }
 
         private static ExprKind GetAssignmentOperation(Context cx, AssignmentExpressionSyntax syntax)
@@ -105,56 +103,5 @@ private static ExprKind GetKind(Context cx, AssignmentExpressionSyntax syntax)
 
             return kind;
         }
-
-        /// <summary>
-        /// Gets the kind of this assignment operator (<code>null</code> if the
-        /// assignment is not an assignment operator). For example, the operator
-        /// kind of `*=` is `*`.
-        /// </summary>
-        private ExprKind? OperatorKind
-        {
-            get
-            {
-                var kind = Kind;
-                if (kind == ExprKind.REMOVE_EVENT || kind == ExprKind.ADD_EVENT || kind == ExprKind.SIMPLE_ASSIGN)
-                    return null;
-
-                if (CallType.AdjustKind(kind) == ExprKind.OPERATOR_INVOCATION)
-                    return ExprKind.OPERATOR_INVOCATION;
-
-                switch (kind)
-                {
-                    case ExprKind.ASSIGN_ADD:
-                        return ExprKind.ADD;
-                    case ExprKind.ASSIGN_AND:
-                        return ExprKind.BIT_AND;
-                    case ExprKind.ASSIGN_DIV:
-                        return ExprKind.DIV;
-                    case ExprKind.ASSIGN_LSHIFT:
-                        return ExprKind.LSHIFT;
-                    case ExprKind.ASSIGN_MUL:
-                        return ExprKind.MUL;
-                    case ExprKind.ASSIGN_OR:
-                        return ExprKind.BIT_OR;
-                    case ExprKind.ASSIGN_REM:
-                        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:
-                        return ExprKind.BIT_XOR;
-                    case ExprKind.ASSIGN_COALESCE:
-                        return ExprKind.NULL_COALESCING;
-                    default:
-                        Context.ModelError(Syntax, $"Couldn't unfold assignment of type {kind}");
-                        return ExprKind.UNKNOWN;
-                }
-            }
-        }
-
-        public new CallType CallType => GetCallType(Context, Syntax);
     }
 }