Output "unsupported extern" warnings only if used

[marzipankaiser]

When compiling an extern definition like

extern def foo(): Unit = js """
    "foo"
"""

in a non-matching backend (e.g. chez), we output a warning.
It would be nice to only output this warning if the definition is actually used (reachable transitively from main).

(Future work from #427)

[marzipankaiser]

blocks #449

[b-studios]

This is indeed a blocker... Sadly the different backends define different methods (for instance to convert internal representations), that will never be available / implemented by other backends.

Right now, this means I cannot run the tests.

If you have an idea on how to fix it, you could also try the fix immediately on #449

[b-studios]

Why would "simply" moving the check to a later stage not work again?

[marzipankaiser]

Because when resolving externs, we elaborate unsupported ones to holes. We still need to transform them to something if we don't want weird undefined things in later stages. To be precise:

extern def foo(): Unit = js "..."

becomes (except in js) something like

def foo(): Unit = <>

So we cannot distinguish it from a normal definition anymore.

Also, in later stages error reporting is less nice (though we could partially solve that via the symbol).

[marzipankaiser]

C: When emitting the warning, check if live (feature/better-extern-warnings-C)

(Problems occur with imported unsupported externs.)

I just tried going another route (find out if we are "live" first before emitting the warning). One of the issues is: What is main? Especially when I'm in a pre-Aggregate phase (which is: all on source).

Another alternative in that direction would be to generate the warnings with a marker and filter them out when we filter warnings (which we seem to do anyway), potentially "only when used" would also be useful for other warnings.

[marzipankaiser]

I experimented a bit on this and found out with the following variants:

A: resolve unsupported externs to a extern def with a special Unsupported body. (feature/better-extern-warnings-A)

The main problem I run into is:

• If I do not replace the extern def with a def in source, we can't do so later in core (because core potentially assumes a different calling convention - one of the reasons it is so early).
• If I don't (I leave it as an extern), then I have to thread this through until it reaches the backend. I.e., every backend has to explicitly generate code for unsupported externs (in contrast, right now they mostly do not have to care: They will get a hole <> as the right hand side of a "normal" definition). The linked branch implements this for non-lift backends and errors out in LiftInference.

B: resolve unsupported externs to a def with a special ReportIfReachable body (feature/better-extern-warnings-B)

(i.e. a statement that will report some errors/warnings when it is found in core later)

• Also needs backends to be aware (but not necessarily handle - can be "removed" by separate core phase).
• Will need some special handling for captures: If the extern is -> Unit, it will be considered pure by the optimizer - and thus eliminated, dropping the warning. The linked branch manually annotates ReportIfReachable as IO+Control to prevent this.

[marzipankaiser]

(Note from quick chat: We probably want something more like A)