Add Increment and AddAssign Expressions

[TheBrambleShark]

These are just quality of life improvements for developers. Although the language has support for myNumber++ and myNumber += anotherNumber, UiPath has no way to use these directly. The best we have currently is to use the Assign activity and manually add the correct number.

An AddAssign and Increment expression would be the first step in promoting this functionality in UiPath. The following are sample implementations of these expressions from my own code base. I multitarget from net462 up through net7.0, hence the ifdefs, which may be excluded in the official implementation (or included for whenever we update to Net7 or Net8). Nullable is enabled in this context, hence the null! declarations.

If this is something we are interested in, I am interested in implementing these features, though I'll break these out into two separate issues/PRs.

/// <summary>
/// A code activity which increments a numeral.
/// </summary>
/// <typeparam name="TNumeral">A numeric value, such as <see langword="int"/> or <see langword="long"/>.</typeparam>
public sealed class Increment<TNumeral> : CodeActivity<TNumeral>
#if NET7_0_OR_GREATER
    where TNumeral : INumber<TNumeral>
#endif
{
    private static Func<TNumeral, TNumeral> operationFunction = null!;

    /// <summary>
    /// Gets or sets the numeral value that will be incremented.
    /// </summary>
    [RequiredArgument]
    [DefaultValue(null)]
    public InOutArgument<TNumeral> Numeral { get; set; } = null!;

    /// <inheritdoc/>
    protected override void CacheMetadata(CodeActivityMetadata metadata)
    {
        BinaryExpressionHelper.OnGetArguments(metadata, Numeral);

        Increment<TNumeral>.EnsureOperationFunction(metadata, ref operationFunction, ExpressionType.Increment);
    }

    private static void EnsureOperationFunction(CodeActivityMetadata metadata, ref Func<TNumeral, TNumeral> operationFunction, ExpressionType operatorType)
    {
        if (operationFunction == null)
        {
            if (!BinaryExpressionHelper.TryGenerateUnaryDelegate(operatorType, out operationFunction!, out ValidationError? validationError))
            {
                metadata.AddValidationError(validationError);
            }
        }
    }

    /// <inheritdoc/>
    protected override TNumeral Execute(CodeActivityContext context)
    {
        TNumeral value = Numeral.Get(context);
        return operationFunction.Invoke(value);
    }
}

/// <summary>
/// A code activity which incrementally assigns a numeral.
/// </summary>
/// <example>
/// int myNum = 5;
/// myNum += 5; // 10.
/// </example>
/// <typeparam name="TLeft">The operand to modify.</typeparam>
/// <typeparam name="TRight">The operand with which to modify <typeparamref name="TLeft"/>.</typeparam>
/// <typeparam name="TResult">The resulting type of hte operation.</typeparam>
public sealed class AddAssign<TLeft, TRight, TResult> : CodeActivity<TResult>
#if NET7_0_OR_GREATER
    where TLeft : INumber<TLeft>
    where TRight : INumber<TRight>
    where TResult : INumber<TResult>
#endif
{
    private static Func<TLeft, TRight, TResult> checkedOperationFunction = null!;
    private static Func<TLeft, TRight, TResult> uncheckedOperationFunction = null!;

    /// <summary>
    /// Gets or sets the left operand which will be modified by this operation.
    /// </summary>
    [RequiredArgument]
    [DefaultValue(null)]
    public InArgument<TLeft> Left { get; set; } = null!;

    /// <summary>
    /// Gets or sets the right operand which will be the modifier for this operation.
    /// </summary>
    [RequiredArgument]
    [DefaultValue(null)]
    public InArgument<TRight> Right { get; set; } = null!;

    /// <summary>
    /// Gets or sets a value indicating whether this operation will happen in a checked or unchecked context.
    /// </summary>
    [DefaultValue(true)]
    public bool IsChecked { get; set; } = true;

    /// <inheritdoc/>
    protected override void CacheMetadata(CodeActivityMetadata metadata)
    {
        BinaryExpressionHelper.OnGetArguments(metadata, Left, Right);

        if (IsChecked)
        {
            AddAssign<TLeft, TRight, TResult>.EnsureOperationFunction(metadata, ref checkedOperationFunction, ExpressionType.AddAssignChecked);
        }
        else
        {
            AddAssign<TLeft, TRight, TResult>.EnsureOperationFunction(metadata, ref uncheckedOperationFunction, ExpressionType.AddAssign);
        }
    }

    private static void EnsureOperationFunction
    (
        CodeActivityMetadata metadata,
        ref Func<TLeft, TRight, TResult> operationFunction,
        ExpressionType operatorType
    )
    {
        if (operationFunction == null)
        {
            if (!BinaryExpressionHelper.TryGenerateLinqDelegate(
                operatorType,
                out operationFunction,
                out ValidationError validationError))
            {
                metadata.AddValidationError(validationError);
            }
        }
    }

    /// <inheritdoc/>
    protected override TResult Execute(CodeActivityContext context)
    {
        TLeft leftValue = Left.Get(context);
        TRight rightValue = Right.Get(context);

        // If user changed checked flag between open and execution, an NRE may be thrown.
        // This is by design.
        return IsChecked
            ? checkedOperationFunction(leftValue, rightValue)
            : uncheckedOperationFunction(leftValue, rightValue);
    }
}