Enable "Compiler warnings" preference by default

[nuket]

Describe the request

Enable compiler warnings by default by changing the default value of the "Compiler warnings" preference.

🙂 Important information about potential problems in Arduino code will be visible to more Arduino IDE users.
🙂 Developers of shared Arduino projects will be encouraged to write warning-free code

Describe the current behavior

The default value of the "Compiler warnings" preference is "None"

🙁 Users might suffer from bugs that are difficult to troubleshoot without assistance from the compiler.
🙁 Developers of shared Arduino projects are not aware that their code produces warnings and so don't fix them. These warnings then make it more difficult for users of dependent projects who do enable warnings to differentiate the warnings in their own code from the warnings from the dependencies.

Arduino IDE version

Original report

1.6.6

Last verified with

73b6dc4

Operating system

All

Operating system version

Any

Additional context

Defaulting to not showing warnings is, overall, a bad thing for the ecosystem. Advanced users will have a hard time taking it seriously, when instead of owning the errors, the IDE sweeps them under the rug.

Additional requests

• Set warnings to "default" by default #1792
• Enable compiler warnings by default in User Preferences #2316

Issue checklist

• I searched for previous requests in the issue tracker
• I verified the feature was still missing when using the latest nightly build
• My request contains all necessary details

[ffissore]

You miss the passage from "totally unable to write a sketch" to "novice". Warnings are unnecessary to the formers and, classes prove, scare them away. Becoming a novice is a big achievement, while going from novice to expert it's just a matter of time and dedication.
I'm therefore closing this as wontfix.

[nuket]

Sure, but if Show verbose output during compilation is disabled anyways, then if I've made the effort to enable it, I'd expect warnings to be shown by default. Do novices usually enable that option? Probably not. I would not expect Compiler warnings to be set to None by default. That's useless. As in, what's the point of turning on verbose output to see no additional information that helps you solve your problem?

Setting Show verbose output during compilation to False and Compiler warnings to All. would be ideal.

Again, this should be highlighted in bold on the Arduino website somewhere, because when I see libraries emitting warnings, I know the authors also didn't see them. This isn't just about the novices, this is about the ecosystem of code and advanced users around them too.

[ffissore]

Don't get me wrong: I would turn on warnings by default without giving users an option to turn them off!

However, we have to deal with a ton of already written documentation/books/blogs/tweets/you name it, which (precisely or not) shout out loud what are the side effects of each and every button/checkbox/menu.

This is why we have two distinct options for turning on verbose output and warnings (verbose output is usually used to find out where the IDE has saved intermediate files)
And btw, setting warnings level is a recent feature (since 1.6.4)

[nuket]

That would be awesome.

I had used the verbose output to view the commands used, but yes the default assumption that warnings would be provided, that's what caught me off guard. In this case, I think more detail would be better, otherwise, verbose output isn't as helpful as it could be.

I think one underlying reason why warnings are off by default is GCC not having very clear warnings (to novices anyways). Even advanced users usually have to read those warnings twice, just to figure out what the hell GCC is talking about.

[ffissore]

Having clang would really be awesome! We could add autocomplete and use its beautiful error messages. @cmaglie was working on it

[nuket]

Yup. I've actually been working on a script to build Makefiles that would let you use Xcode as an editor and could run syntax checking using the OS X clang. Kind of like X-AVR, but parsing the platform.txt, boards.txt, and programmers.txt files directly to generate projects.

X-AVR already does a pretty good job of getting the indexing and autocomplete working for the native AVR libc and hardware headers.

[matthijskooijman]

@ffissore, I would ask to reconsider this ticket. I asked the original reported to report it after this got mentioned in another issue.

While adding the warning option, we discussed that it would be good to enable warnings by default, at least for the sketch itself (i.e. so only warnings that the user should be able to fix are reported, unlike warnings in the core and library which are effectively opaque to novice users). Also, we considered making a selection of warnings that are clear and easy to fix, and keep the complex warnings disabled by default. We initially didn't implement this, just to get the warning option out there sooner and perhaps collect some feedback, but I still feel that implementing something like this so we can enable (most) warnings by default is important and should be tracked in this issue.

[mikaelpatel]

This has been discussed in detail before. Please see arduino/Arduino#1728.

[cousteaulecommandant]

Although I don't think -Wextra should be enabled by default since as ffissore said it might scare newcomers, I think the -Wall flag would solve a lot of common problems.

• -Wall: Are you SURE you meant to write if (x = 0)?
• -Wextra: You're comparing a signed with an unsigned, are you CRAZY?!

In other words, -Wall is not really THAT scary; most of the time it indicates actual mistakes. -Wextra is a bit more paranoid and gives many "false positives", so it's probably not a good idea to enable it by default. And in any case, the default warnings (with no -Wall nor -Wextra) are only the REALLY problematic ones, so at the very least I'd remove the -w option.

Also, not using -Wall hides some potential misbehaviors, such as signed overflow:

boolean will_overflow(int x) {
    int y = x+1;
    return y < x;
}

    will_overflow(INT_MAX)  // returns false instead of true

When compiled with -Wall, this shows: sketch.ino: warning: assuming signed overflow does not occur when assuming that (X + c) < X is always false [-Wstrict-overflow], which might be a bit cryptic but suggests that there's probably a problem there. Indeed, regardless of what the Arduino documentation for int says, overflowing a signed integer should never be done, so the compiler is free to assume that'll never happen, resulting in the function being "optimized" so that it always returns false.

[matthijskooijman]

I'm reopening this one, as I still think we should be moving towards having some warnings enabled by default for at least the sketch itself. Also see arduino/ArduinoCore-avr#268, which is somewhat related.