C#: Do not change kind of increment/decrement expressions to operator invocations and cleanup the implementation.

Author: michaelnebel

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

@@ -58,10 +58,10 @@ internal static Expression Create(ExpressionNodeInfo info)
                         return Invocation.Create(info);
 
                     case SyntaxKind.PostIncrementExpression:
-                        return PostfixUnary.Create(info.SetKind(ExprKind.POST_INCR), ((PostfixUnaryExpressionSyntax)info.Node).Operand);
+                        return PostfixUnary.Create(info.SetKind(ExprKind.POST_INCR));
 
                     case SyntaxKind.PostDecrementExpression:
-                        return PostfixUnary.Create(info.SetKind(ExprKind.POST_DECR), ((PostfixUnaryExpressionSyntax)info.Node).Operand);
+                        return PostfixUnary.Create(info.SetKind(ExprKind.POST_DECR));
 
                     case SyntaxKind.AwaitExpression:
                         return Await.Create(info);
@@ -254,7 +254,7 @@ internal static Expression Create(ExpressionNodeInfo info)
                         return Switch.Create(info);
 
                     case SyntaxKind.SuppressNullableWarningExpression:
-                        return PostfixUnary.Create(info.SetKind(ExprKind.SUPPRESS_NULLABLE_WARNING), ((PostfixUnaryExpressionSyntax)info.Node).Operand);
+                        return PostfixUnary.Create(info.SetKind(ExprKind.SUPPRESS_NULLABLE_WARNING));
 
                     case SyntaxKind.WithExpression:
                         return WithExpression.Create(info);

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

@@ -4,27 +4,21 @@
 
 namespace Semmle.Extraction.CSharp.Entities.Expressions
 {
-    internal class PostfixUnary : Expression<ExpressionSyntax>
+    internal class PostfixUnary : Expression<PostfixUnaryExpressionSyntax>
     {
-        private PostfixUnary(ExpressionNodeInfo info, ExprKind kind, ExpressionSyntax operand)
-            : base(info.SetKind(UnaryOperatorKind(info.Context, kind, info.Node)))
+        private PostfixUnary(ExpressionNodeInfo info)
+            : base(info)
         {
-            this.operand = operand;
-            operatorKind = kind;
         }
 
-        private readonly ExpressionSyntax operand;
-        private readonly ExprKind operatorKind;
-
-        public static Expression Create(ExpressionNodeInfo info, ExpressionSyntax operand) => new PostfixUnary(info, info.Kind, operand).TryPopulate();
+        public static Expression Create(ExpressionNodeInfo info) => new PostfixUnary(info).TryPopulate();
 
         protected override void PopulateExpression(TextWriter trapFile)
         {
-            Create(Context, operand, this, 0);
+            Create(Context, Syntax.Operand, this, 0);
             AddOperatorCall(trapFile, Syntax);
 
-            if ((operatorKind == ExprKind.POST_INCR || operatorKind == ExprKind.POST_DECR) &&
-                Kind == ExprKind.OPERATOR_INVOCATION)
+            if (Kind == ExprKind.POST_INCR || Kind == ExprKind.POST_DECR)
             {
                 trapFile.mutator_invocation_mode(this, 2);
             }

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

@@ -6,28 +6,20 @@ namespace Semmle.Extraction.CSharp.Entities.Expressions
 {
     internal class Unary : Expression<PrefixUnaryExpressionSyntax>
     {
-        private Unary(ExpressionNodeInfo info, ExprKind kind)
-            : base(info.SetKind(UnaryOperatorKind(info.Context, info.Kind, info.Node)))
+        private Unary(ExpressionNodeInfo info)
+            : base(info)
         {
-            operatorKind = kind;
         }
 
-        private readonly ExprKind operatorKind;
 
-        public static Unary Create(ExpressionNodeInfo info)
-        {
-            var ret = new Unary(info, info.Kind);
-            ret.TryPopulate();
-            return ret;
-        }
+        public static Expression Create(ExpressionNodeInfo info) => new Unary(info).TryPopulate();
 
         protected override void PopulateExpression(TextWriter trapFile)
         {
             Create(Context, Syntax.Operand, this, 0);
             AddOperatorCall(trapFile, Syntax);
 
-            if ((operatorKind == ExprKind.PRE_INCR || operatorKind == ExprKind.PRE_DECR) &&
-                Kind == ExprKind.OPERATOR_INVOCATION)
+            if (Kind == ExprKind.PRE_INCR || Kind == ExprKind.PRE_DECR)
             {
                 trapFile.mutator_invocation_mode(this, 1);
             }