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

Author: michaelnebel

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

@@ -263,16 +263,6 @@ type.SpecialType is SpecialType.System_IntPtr ||
             return si.Symbol as IMethodSymbol;
         }
 
-        /// <summary>
-        /// Adapt the operator kind depending on whether it's a dynamic call or a user-operator call.
-        /// </summary>
-        /// <param name="cx"></param>
-        /// <param name="node"></param>
-        /// <param name="originalKind"></param>
-        /// <returns></returns>
-        public static ExprKind UnaryOperatorKind(Context cx, ExprKind originalKind, ExpressionSyntax node) =>
-            GetCallType(cx, node).AdjustKind(originalKind);
-
         /// <summary>
         /// If the expression calls an operator, add an expr_call()
         /// to show the target of the call. Also note the dynamic method

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

@@ -10,7 +10,17 @@ internal class Cast : Expression<CastExpressionSyntax>
         private const int ExpressionIndex = 0;
         private const int TypeAccessIndex = 1;
 
-        private Cast(ExpressionNodeInfo info) : base(info.SetKind(UnaryOperatorKind(info.Context, ExprKind.CAST, info.Node))) { }
+        private Cast(ExpressionNodeInfo info) : base(info.SetKind(GetKind(info.Context, ExprKind.CAST, info.Node))) { }
+
+        /// <summary>
+        /// Adapt the operator kind depending on whether it's a dynamic call or a user-operator call.
+        /// </summary>
+        /// <param name="cx"></param>
+        /// <param name="node"></param>
+        /// <param name="originalKind"></param>
+        /// <returns></returns>
+        public static ExprKind GetKind(Context cx, ExprKind originalKind, ExpressionSyntax node) =>
+            GetCallType(cx, node).AdjustKind(originalKind);
 
         public static Expression Create(ExpressionNodeInfo info) => new Cast(info).TryPopulate();
 

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);
             }