Add a pragma to suppress warnings

[jimbxb]

Ideally, this suppression should be scoped. That is, a suppression should apply to a whole file, a module within that file, or even to a single proc. These pragmas should be extendable to support different classes of warnings, though my motivating example is for unused parameters.

pragma suppress(unused) # suppress "unused" warnings for the current file

module mod {
    pragma suppress(unused) # only in mod
}

def foo(unused_param:T) {
    pragma supress(unused) # only in foo
}

I'm not sure I like the pragma being inside foo, but I want to distinguish it from a file/module-level suppression. Perhaps we should warn if such a suppression is not the first "statement" in a module.

Implementation wise, I think we should still generate these warnings, and then only when we are printing warnings should we decide if a warning should or should not be suppressed. That would keep the concern of generating the warning separate from the suppression. Each warning should then be tagged with a "class" of warning, along with its module, to decide to suppress it or not.

[pschachte]

OK, that looks good, and flexibly precise. It also extends nicely to allow warnings that are off by default, and can be turned on with a pragma warn(...) directive.

Not sure if I like this better, but an alternative to pragma suppress inside a proc/func declaration (actually, inside a func would be messy) would be to allow one or more proc/func definitions to be written inside braces, and any enclosed pragma suppress directives would apply to all of them.

There's something uncomfortably recursive about a directive to suppress warnings about the placement of directives to suppress warnings. I assume there would be a directive to suppress that warning, and if so, where would it need to be placed? ;-)

[jimbxb]

Defs inside braced terms at the top-level seems a little clunky. It could work, but I'm not sure I like it. Maybe a proc-level pragma should live just after a resource-clause, if there is one.

def foo(unused:T) pragma suppress(unused) {
    # you get the drill
}

That's a little verbose, but I suspect this wouldn't be very common, so I don't mind it.

---

A suppress(all) directive would be nice. A warn(error), to convert all warnings to errors would be useful, also.