[Bug c/39985] Type qualifiers not actually ignored on function return type

[Bug c/39985] Type qualifiers not actually ignored on function return type

[muecker at gwdg dot de]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=39985

Martin Uecker <muecker at gwdg dot de> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |muecker at gwdg dot de

--- Comment #10 from Martin Uecker <muecker at gwdg dot de> ---

It seems this is fixed in 11.1:

https://gcc.godbolt.org/z/nMqz8sG1v

[Bug c/39985] Type qualifiers not actually ignored on function return type

[mpolacek at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=39985

Marek Polacek <mpolacek at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
         Resolution|---                         |FIXED
             Status|ASSIGNED                    |RESOLVED
                 CC|                            |mpolacek at gcc dot gnu.org

--- Comment #11 from Marek Polacek <mpolacek at gcc dot gnu.org> ---
Closing as fixed then.

[Bug c/39985] Type qualifiers not actually ignored on function return type

[anders at kaseorg dot com]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1497 bytes --]



------- Comment #3 from anders at kaseorg dot com  2009-11-27 07:33 -------
> my inclination is that we should eliminate the inconsistent attempts to give
> rvalues qualified types in some cases, and say that if the operand of typeof
> is not an lvalue it never has a qualified type.

Should typeof ever return a qualified type?  It is easy to add qualifiers to a
type if they are desired (const typeof(foo)), but seems difficult to remove
them.

For example, seemingly reasonable macros like
  #define MAX(__x, __y) ({           \
      typeof(__x) __ret = __x;       \
      if (__y > __ret) __ret = __y;  \
      __ret;                         \
  })
currently fail when given a qualified argument:
  const int c = 42;
  MAX(c, 17);  /* error: assignment of read-only variable ‘__ret’ */

This bug report was motivated by my attempts to fix a macro like this, by
replacing typeof(__x) with something that strips qualifiers.  These all fail to
strip qualifiers:
  typeof( ({ __x; }) )
  typeof( ((typeof(__x)(*)(void)) 0)() )
  typeof( (typeof(__x)) (__x) )
This seems to work, but only for numeric and pointer types:
  typeof( (typeof(__x)) 0 )
This succeeds at stripping qualifiers for numeric types, but for some reason it
promotes char and short to int, and it fails to strip qualifiers for
non-numeric types:
  typeof( 1 ? (__x) : (__x) )

Much confusion would be avoided if typeof(__x) just stripped qualifiers to
begin with.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=39985

[Bug c/39985] Type qualifiers not actually ignored on function return type

[jsm28 at gcc dot gnu dot org]

------- Comment #2 from jsm28 at gcc dot gnu dot org  2009-11-22 20:24 -------
If you wish to report a C++ bug, it needs to have component "c++" and be
a separate bug from any bug report for C front-end issues; comments
about possible C++ front-end issues in "c" bugs are irrelevant except insofar
as they illuminate questions of what the C front end should do.

For C, the qualifiers are ignored as far as standard terms are concerned.
Whether typeof applied to an rvalue in GNU C has a qualified types is
fundamentally confused at present; my inclination is that we should
eliminate the inconsistent attempts to give rvalues qualified types in
some cases, and say that if the operand of typeof is not an lvalue it
never has a qualified type.


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=39985

[Bug c/39985] Type qualifiers not actually ignored on function return type

[gcc at magfr dot user dot lysator dot liu dot se]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 942 bytes --]



------- Comment #1 from gcc at magfr dot user dot lysator dot liu dot se  2009-11-21 12:24 -------
Created an attachment (id=19074)
 --> (http://gcc.gnu.org/bugzilla/attachment.cgi?id=19074&action=view)
Test case - g++ -Wignored-qualifiers test.C gives confusing results

In C++ it becomes even worse since the types are used more.

As it stands right now it becomes ridiculous:

$ g++ -Wignored-qualifiers test.C
test.C:12: warning: type qualifiers ignored on function return type
test.C:12: error: conflicting return type specified for ‘virtual const int
D1::F()’
test.C:5: error:   overriding ‘virtual int B1::F()’
test.C:20: warning: type qualifiers ignored on function return type
test.C:27: error: conflicting return type specified for ‘virtual int D2::F()’
test.C:20: error:   overriding ‘virtual const int B2::F()’

Are the type qualifiers ignored or are they not?


-- 


http://gcc.gnu.org/bugzilla/show_bug.cgi?id=39985