Compile-time vs. compile-time

[Jonathan M Davis]

On Thursday, January 04, 2018 14:59:44 H. S. Teoh via Digitalmars-d wrote:
> On Wed, Jan 03, 2018 at 02:44:21PM +0100, ag0aep6g via Digitalmars-d 
wrote:
> > On 01/03/2018 02:51 AM, H. S. Teoh wrote:
> > >   https://wiki.dlang.org/User:Quickfur/Compile-time_vs._compile-time#Bu
> > >   t_what_of_runtime_performance.3F> >
> > > object.destroy! :-P
> >
> > In the CTFE section, you explain that it came from constant folding,
> > but you don't point out how the two are different. After reading the
> > section, a newbie might think that the term "CTFE" is for when
> > constant folding evaluates function calls. But that's not what we mean
> > by "CTFE".
> >
> > What's missing is that CTFE is forced/guaranteed. It's not an
> > optimization.  When we say "CTFE", we mean the cases where compilation
> > fails if the expression cannot be evaluated.
>
> I wouldn't say that CTFE means that it is forced/guaranteed. But you're
> right that it could be confusing the way I described it.  I added a
> section to clarify that usually the compiler would not use CTFE to
> constant-fold complex expressions, unless the value is required at
> compile-time.
>
> > I doesn't help that the `i` variables in the examples are (seemingly)
> > globals, but you also talk about putting them in a "busy inner loop".
> > If I just copy the code as it is, `i` is a global and I get actual
> > CTFE. If I put `i` in a loop, it's a local and it's up to the compiler
> > if it does non-CTFE constant folding.
>
> Are you sure that's non-CTFE?  Isn't standard constant folding a part of
> CTFE?  Anyway, the new section should clear up the confusion.

As I understand it, CTFE and constant folding aren't really related at all.
Obviously, a value that was generated as part of CTFE could then take part
in constant folding if appropriate, because once the value is generated, it
really isn't any different from if that value were written by hand. However,
CTFE is never done as a compiler optimization. It's only ever done because a
value is required at compile time. So, constant folding won't even trigger
CTFE, just like the compiler will never decide that it might be more
efficient to call a function at compile time and thus call it at compile
time instead of runtime.

- Jonathan M Davis