VB.NET division / integer division

[zspitz]

VB.NET has two modes for division: simple division, which will return the same answer irrespective of type:

Dim i1 =11, i2 = 4
Dim result = i1 / i2
Console.WriteLine(result)
' prints 2.75

and integer division, which rounds the operands down or up, carries out the division, and rounds the answer again to an integer:

Dim i1 =11.0, i2 = 1.1
Dim result = i1 \ i2
Console.WriteLine(result)
' prints 11

Perhaps we should render the expression resulting from integer division differently.

[zspitz]

This issue is also applicable to the C# writer/visitor. Consider the following:

var i = 5;
var d = 4.0;
var expr = Expr(() => i / d); // the Expr function takes a lambda syntax and returns the corresponding expression
Console.WriteLine(expr.ToString("C#"));

which produces:

() => (double)i / d

The explicit conversion to double is unnecessary; this is something the C# compiler inserts.

---

In short, for C#, a conversion will be implicitly added by the compiler, if either of the expressions has a different type than the other. (Whether it's converting to an integral type or a non-integral type, depends on if any of the operand expressions is non-integral -- the integral will be converted to an appropriate non-integral and non-integer division will be used -- or if all of the operand expressions are integral -- only converted if they aren't the same type; they'll be converted to the wider of the two types, but integer division will be used.)

For VB, conversion will be introduced if the integrality of either or both of the operands doesn't match the integrality of the operation, or if one of the types is wider than the other.

---

For C#:

1. If the conversion is a widening conversion, there's no need to render it.
2. The operation is always rendered with /.

For VB:

1. If the operands after conversion are both integral, use the integer division operator (\).
2. If the operands after conversion are both non-integral, use the non-integer division operator (/).
3. Like C#, only render narrowing conversions.

From my testing, this fails:

var expr = Expression.Divide(
    Expression.Constant(5.0m, typeof(decimal)),
    Expression.Constant(5.0, typeof(double))
);

unless the types of the two operands are the same; it seems there's no way to construct a division BinaryExpression with operands of different types.

[zspitz]

Tests:

• Widening conversions don't need to be rendered; test expressions in C#, VB
• Narrowing conversions do need to be rendered; test expressions in C#, VB
• Expressions that use integer division - VB explicit operator, C# operands are integral
• Expressions that use non-integer division - VB explicit operator, C# one operand is non-integral

[zspitz]

The widening conversions issue is being tracked at #68 . Once that's fixed we can finish this.