Coteries: a clarification

[Ivan Godard <igodard@xxxxxxxxxxx>]

There seems some confusion about "licensing the compiler". There are 
three cases of interest"

1) When the program controls the coterie of all data, by declaration and 
by explicit rules for intermediates. This is portable.
2) When the compiler chooses (some of) the coteries for declared 
variables, but the points at which coteries are changed in expressions 
are controlled by the explicit rules. With care the standard can be 
written so that the coteries chosen will be consistent and predictable 
for any given platform and so are (indirectly) under programmer control. 
This is not portable to other platforms but will give consistent results 
within any single platform.
3) Where the compiler chooses the points at which coteries are changed 
in expressions, whether or not it chose the coteries of declared 
variables. This is not in general portable to other platforms or even 
consistent within a single platform, and apparently minor source changes 
may affect result of operations remote from the change. However, it will 
usually give the most performant and may give the most precise results.

All three of these possibilities are meaningful and may be desirable for 
certain applications, and it is reasonable to support them in the 
standard. However, there has been some idea that it is possible to 
achieve the benefit of case #3 while retaining the benefits of case #2 
(or case #1) by suitable constraining (probably by source annotation) 
the scope within which the compiler is licensed. This idea is false, 
however much to be hoped. It is in general impossible to define such a 
constraint mechanism without also so constraining other compiler 
activities that the compiler will in fact ignore its license and give 
you case #1 throughout. Or give you case #3 throughout, and standard be 
damned.

Ivan