Should unused record variables be removed?

[mppf]

If a non-POD record is declared and never used, should the compiler emit a default-init/deinit pair, or just completely remove the record?

For example:

record R {
  proc init() { writeln("init"); }
  proc deinit() { writeln("deinit"); }
}

proc test() {
  var x: R;
}
test();

Here the variable x is unused, and the init and deinit functions have side effects.

Here we have three options:

1. Decide that code declaring variables without using them is bad code. Warn the user that x is unused since that's probably unintentional.
2. Dead-code eliminate x in the above example, so that it is neither initialized nor deinitialized. The program above would have no output.
3. Run the initializer and de-initializer above for side effects. The program above would print out init and then deinit.

Although it might be bad style, what if a user wanted to create a "Computation" record that did all of the computation in its initializer? Would we be willing to eliminate that too? If not, why should a default-initializer be different?

As of PR #14691, the compiler uses option 3, but it is worth discussing if we want to use a different strategy.

[bradcray]

I'd probably take the approach of leaving the variable in, calling its init and deinit, but warning the user that it's unused and having a flag to turn that warning off.

[vasslitvinov]

The closest counterpart of (2) is moving a record from one variable to another:

var x: R;
var y = x;
// x is unused here

or

proc makeR() {
  var x = new R();
  return x;
}
var y = makeR();

where in each example the compiler could emit only one init/deinit pair instead of two.

[vasslitvinov]

I can see a couple of arguments in favor of (2).

• From a software engineering perspective, the initializer and deinitializer are intended to have only the setup/tear-down computations. Where the "setup" sets things up for the bulk of the computation that will be executed later. If the user desires to run some computation with just a single statement, a type method - or a non-method function - is more appropriate than an unused variable.

• No need to warn the user. If it matters that init+deinit are executed, it should be easy for the user to notice that they are not. Then they can change their code to execute the desired code in other ways.

Other than that, I do not have a preference among the listed options.

[cassella]

Would this apply if r's initialization was explicit (var r = new R();), but the variable were otherwise unused? That sounds like an RAII pattern. edit: Even with just the default-init, it could be RAII if the type was managing a single global lock.

Would the warning/optimization be done before or after param folding?

[mppf]

@cassella - as it is we're not planning to support things like RAII locks directly (at least not without adding other things) because we will deinitialize such variables before the end of the block (after PR #14691 and according to the proposal in #14691).

Nonetheless the "should it apply if initialization was explicit" question is what I was trying to get at with "If not, why should a default-initializer be different?". I think the answer might be different here if we are dead-code-eliminating vs. warning.

Would the warning/optimization be done before or after param folding?

If we did a warning, I'd expect it to happen before param folding. If we dead-code-eliminate, I'd expect it to happen after.