From: jaruga@...
Date: 2018-09-20T08:31:02+00:00
Subject: [ruby-core:89103] [Ruby trunk Misc#15136] Fix -Wparentheses warnings

Issue #15136 has been updated by jaruga (Jun Aruga).


> IIRC, matz has rejected the 1st case, and preferred explicit comparison with 0.

@nobu you mean basically like this?


```
if (success = compile_c_to_o(c_file, o_file)) {
```

to


```
if ((success = compile_c_to_o(c_file, o_file)) != 0) {
```

(In case of compile_c_to_o function, the return value: 0 is success case, otherwise error case.)

I will update and rebase my pull-request for the way.





----------------------------------------
Misc #15136: Fix -Wparentheses warnings
https://bugs.ruby-lang.org/issues/15136#change-74123

* Author: jaruga (Jun Aruga)
* Status: Open
* Priority: Normal
* Assignee: 
----------------------------------------
Currently the `-Wno-parentheses` was set.
I assumed if we could fix the warning, we could remove the `-Wno-parentheses`.

I fixed the warnings, because the warning is used as a default on Fedora Project build environment.
I sent pull-request. https://github.com/ruby/ruby/pull/1958

I would show you the explanation of `-Wparentheses`.

```
$ man gcc (or gcc --help --verbose)
...
       -Wparentheses
           Warn if parentheses are omitted in certain contexts, such as when there is an
           assignment in a context where a truth value is expected, or when operators are
           nested whose precedence people often get confused about.

           Also warn if a comparison like "x<=y<=z" appears; this is equivalent to "(x<=y ?
           1 : 0) <= z", which is a different interpretation from that of ordinary
           mathematical notation.

           Also warn for dangerous uses of the GNU extension to "?:" with omitted middle
           operand. When the condition in the "?": operator is a boolean expression, the
           omitted value is always 1.  Often programmers expect it to be a value computed
           inside the conditional expression instead.

           For C++ this also warns for some cases of unnecessary parentheses in
           declarations, which can indicate an attempt at a function call instead of a
           declaration:

                   {
                     // Declares a local variable called mymutex.
                     std::unique_lock<std::mutex> (mymutex);
                     // User meant std::unique_lock<std::mutex> lock (mymutex);
                   }

           This warning is enabled by -Wall.
...
```





---Files--------------------------------
make.log (96.1 KB)


-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request@ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>