evaluated at compile time

What the difference between two examples?

example 1:
int x = int.MaxValue + 1; // Compile-time error

example 2;
int x = int.MaxValue;
x = x + 1; // no Compile-time error

The Author of A Nutshell book said about the first example that expressions evaluated at compile time are always overflow-checked.

I didn't understand the difference between the first and second examples. Isn't both evaluated at compile time, so should both produce the same error?

int.MaxValue is a constant value, so the compiler can calculate int.MaxValue + 1 and determine that it overflows the range of int.

The compiler is not sophisticated enough to know that x is int.MaxValue, calculate x + 1 and determine that it overflows.

The compiler does not "evaluate" the second - it just turns the expressions into the equivalent IL code that is evaluated when the program runs (which would obviously overflow at runtime).

If the first example used a constant expression that did not overflow (e.g. int.MaxValue - 1), the compiler could replace the expression with the result of the constant expression in the IL.

That's all that's meant by "evaluated at compile-time"

> Isn't both evaluated at compile time, so should both produce the same error?

No, compiler (as far as I know) evaluates only the constant expressions and the second isn't one.

So x + 1 in the following:

int x = int.MaxValue; 
x = x + 1; // no Compile-time error

Is not a constant expression. I.e. if you will change it to:

const int x = int.MaxValue; 
int x1 = x + 1; 

it will produce the compile-time error.

A bit of specification deep dive:

From specification: 12.8.19 The checked and unchecked operators:

> When one of the above operations produces a result that is too large to represent in the destination type, the context in which the operation is performed controls the resulting behavior:

> - In a checked context, if the operation is a constant expression (§12.23), a compile-time error occurs. Otherwise, when the operation is performed at run-time, a System.OverflowException is thrown.

And in the 12.23 Constant expressions part of spec:

> Only the following constructs are permitted in constant expressions:
>
> - Literals (including the null literal).
> - References to const members of class and struct types.
> - References to members of enumeration types.
> - References to local constants.
> - Parenthesized subexpressions, which are themselves constant expressions.
> - Cast expressions.
> - checked and unchecked expressions.
> - nameof expressions.
> - The predefined +, –, !, and ~ unary operators.
> - The predefined +, –, *, /, %, <<, >>, &, |, ^, &&, ||, ==, !=, <, >, <=, and >= binary operators.
> - The ?: conditional operator.
> - sizeof expressions, provided the unmanaged-type is one of the types specified in §23.6.9 for which sizeof returns a constant value.
> - Default value expressions, provided the type is one of the types listed above.

The key difference is that example 2 is two expressions. The first assigns the int x, the second increments it. Example 2 can be re-written as:

int x = int.MaxValue;
x = x + 1;

The point that the author is making is that the compiler doesn't check the second expression for integer overflow.