C#: Extract calls to user defined compound assignments as operator calls.

Author: michaelnebel

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

@@ -0,0 +1,20 @@
+using Microsoft.CodeAnalysis;
+
+namespace Semmle.Extraction.CSharp.Entities.Expressions
+{
+    internal static class CompoundAssignment
+    {
+        public static Expression Create(ExpressionNodeInfo info)
+        {
+            if (info.SymbolInfo.Symbol is IMethodSymbol op &&
+                op.MethodKind == MethodKind.UserDefinedOperator &&
+                !op.IsStatic)
+            {
+                // This is a user-defined instance operator such as `a += b` where `a` is of a type that defines an `operator +=`.
+                // In this case, we want to extract the operator call rather than desugar it into `a = a + b`.
+                return UserCompoundAssignmentInvocation.Create(info);
+            }
+            return Assignment.Create(info);
+        }
+    }
+}

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

@@ -70,6 +70,9 @@ internal static Expression Create(ExpressionNodeInfo info)
                         return NormalElementAccess.Create(info);
 
                     case SyntaxKind.SimpleAssignmentExpression:
+                    case SyntaxKind.CoalesceAssignmentExpression:
+                        return Assignment.Create(info);
+
                     case SyntaxKind.OrAssignmentExpression:
                     case SyntaxKind.AndAssignmentExpression:
                     case SyntaxKind.SubtractAssignmentExpression:
@@ -81,8 +84,7 @@ internal static Expression Create(ExpressionNodeInfo info)
                     case SyntaxKind.UnsignedRightShiftAssignmentExpression:
                     case SyntaxKind.DivideAssignmentExpression:
                     case SyntaxKind.ModuloAssignmentExpression:
-                    case SyntaxKind.CoalesceAssignmentExpression:
-                        return Assignment.Create(info);
+                        return CompoundAssignment.Create(info);
 
                     case SyntaxKind.ObjectCreationExpression:
                         return ExplicitObjectCreation.Create(info);

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

@@ -0,0 +1,40 @@
+using System.IO;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Semmle.Extraction.Kinds;
+
+namespace Semmle.Extraction.CSharp.Entities.Expressions
+{
+    /// <summary>
+    /// Represents a user-defined compound assignment operator such as `a += b` where `a` is of a type that defines an `operator +=`.
+    /// In this case, we don't want to desugar it into `a = a + b`, but instead extract the operator call directly as it should
+    /// be considered an instance method call on `a` with `b` as an argument.
+    /// </summary>
+    internal class UserCompoundAssignmentInvocation : Expression<AssignmentExpressionSyntax>
+    {
+        private readonly ExpressionNodeInfo info;
+
+        protected UserCompoundAssignmentInvocation(ExpressionNodeInfo info)
+            : base(info.SetKind(ExprKind.OPERATOR_INVOCATION))
+        {
+            this.info = info;
+        }
+
+        public static Expression Create(ExpressionNodeInfo info) => new UserCompoundAssignmentInvocation(info).TryPopulate();
+
+        protected override void PopulateExpression(TextWriter trapFile)
+        {
+            Create(Context, Syntax.Left, this, 0);
+            Create(Context, Syntax.Right, this, 1);
+
+            var target = info.GetTargetSymbol(Context);
+            if (target is null)
+            {
+                Context.ModelError(Syntax, "Unable to resolve target method for user-defined compound assignment operator");
+                return;
+            }
+
+            var targetKey = Method.Create(Context, target);
+            trapFile.expr_call(this, targetKey);
+        }
+    }
+}