public inbox for gcc-prs@sourceware.org
help / color / mirror / Atom feed
* Re: c++/10437: "using namespace" at global scope creates incorrect code
@ 2003-04-25 19:46 Wolfgang Bangerth
0 siblings, 0 replies; 6+ messages in thread
From: Wolfgang Bangerth @ 2003-04-25 19:46 UTC (permalink / raw)
To: nobody; +Cc: gcc-prs
The following reply was made to PR c++/10437; it has been noted by GNATS.
From: Wolfgang Bangerth <bangerth@ices.utexas.edu>
To: Dean Foster <foster@diskworld.wharton.upenn.edu>
Cc: gcc-gnats@gcc.gnu.org, <gcc@gcc.gnu.org>
Subject: Re: c++/10437: "using namespace" at global scope creates incorrect
code
Date: Fri, 25 Apr 2003 14:37:44 -0500 (CDT)
> I've shortened it down to about 50 lines. (Took several 100 compiles.
OK, I tested this and I now see two issues here. Number one:
-----------------------
namespace NS {
template <class T> void foo (const T&);
}
template<class T> void bar() {
foo (T());
}
using namespace NS;
int main() {
bar<int>();
}
-----------------------
This compiles. Should it? At the point of declaration of bar(), NS::foo is
not visible, but the call is template dependent (i.e. two-stage name
lookup kicks in), so we also have to take into account everything that is
visible at the point of instantiation, where NS::foo _is_ visible, due to
the global scope using directive. I wasn't aware of the fact, though, that
using directives work retroactively for two-stage name lookup as well.
(icc tends to agree with me here, it rejects the code.)
However, the code stops to compile if the "using" is moved inside main().
I think that for visibility of foo inside bar, only symbols declared in the
scope of main, not inside it should be relevant, which would explain this.
Can someone confirm this?
Point 2: Given the above -- this doesn't compile:
----------------------
template <class T> struct X {
typedef typename T::type_doesnt_exist type;
};
void foo(int);
template <class T>
typename X<T>::inexistent foo (const T&);
template<class T> void bar() { foo(T()); }
int main() { bar<int>(); }
-----------------------
The compiler says:
g/x> ~/bin/gcc-3.4-pre/bin/c++ -c x.cc
x.cc: In instantiation of `X<int>':
x.cc:12: instantiated from `void bar() [with T = int]'
x.cc:16: instantiated from here
x.cc:4: error: `int' is not a class, struct, or union type
Why isn't this just a SFINAE failure, which would lead to the silent
rejection of the foo template? (icc rejects this code as well, so I think
gcc should be right, but I don't understand why.)
W.
-------------------------------------------------------------------------
Wolfgang Bangerth email: bangerth@ices.utexas.edu
www: http://www.ices.utexas.edu/~bangerth/
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: c++/10437: "using namespace" at global scope creates incorrect code
@ 2003-04-25 19:38 bangerth
0 siblings, 0 replies; 6+ messages in thread
From: bangerth @ 2003-04-25 19:38 UTC (permalink / raw)
To: dean, gcc-bugs, gcc-prs, nobody
Synopsis: "using namespace" at global scope creates incorrect code
State-Changed-From-To: closed->analyzed
State-Changed-By: bangerth
State-Changed-When: Fri Apr 25 19:38:54 2003
State-Changed-Why:
I just send an extended analysis. Needs a language lawyer, though.
http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=10437
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: c++/10437: "using namespace" at global scope creates incorrect code
@ 2003-04-21 20:06 Wolfgang Bangerth
0 siblings, 0 replies; 6+ messages in thread
From: Wolfgang Bangerth @ 2003-04-21 20:06 UTC (permalink / raw)
To: nobody; +Cc: gcc-prs
The following reply was made to PR c++/10437; it has been noted by GNATS.
From: Wolfgang Bangerth <bangerth@ices.utexas.edu>
To: Dean Foster <foster@diskworld.wharton.upenn.edu>
Cc: dean@foster.net, <gcc-bugs@gcc.gnu.org>, <gcc-gnats@gcc.gnu.org>
Subject: Re: c++/10437: "using namespace" at global scope creates incorrect
code
Date: Mon, 21 Apr 2003 15:03:33 -0500 (CDT)
> I'm willing to agree that that I've have an error/ambiguity in my
> code. But I don't understand why bringing in a namespace that isn't
> being called should change the ambiguity status.
The point is that in order to find out which function the compiler
shall take, it needs to know about the possibilities. For this, the
possible declarations must "work". Without knowing your choices, you can't
perform overload resolution.
> In other words,
>
> main()
> {
> using namespace foo;
> /* ... */ // no error
> }
> doesn't generate an error. But, the following does generate an error:
>
> using namespace foo;
> main()
> {
> /* ... */ // generates error
> }
>
> It seems that [they] should be the same.
I guess that should be so.
I can't reproduce this with the small example I posted. Can you try to
come up with something short that shows this? Your original example was
incredibly contrived, and I don't want to go through the ordeal again of
reducing it, which took me well over an hour. Hint: try stripping template
parameters, and replacing typedefs by the types the point to, etc. Once
it's well below 100 lines I'll be willing to look at it again :-)
W.
-------------------------------------------------------------------------
Wolfgang Bangerth email: bangerth@ices.utexas.edu
www: http://www.ices.utexas.edu/~bangerth/
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: c++/10437: "using namespace" at global scope creates incorrect code
@ 2003-04-21 19:26 Dean Foster
0 siblings, 0 replies; 6+ messages in thread
From: Dean Foster @ 2003-04-21 19:26 UTC (permalink / raw)
To: nobody; +Cc: gcc-prs
The following reply was made to PR c++/10437; it has been noted by GNATS.
From: Dean Foster <foster@diskworld.wharton.upenn.edu>
To: bangerth@dealii.org, dean@foster.net, gcc-bugs@gcc.gnu.org,
gcc-prs@gcc.gnu.org, nobody@gcc.gnu.org, gcc-gnats@gcc.gnu.org
Cc:
Subject: Re: c++/10437: "using namespace" at global scope creates incorrect code
Date: 21 Apr 2003 19:18:52 -0000
Sorry about forcing you to do more of the reduction. I did at least
remove several 1000 lines of code! But, every time I tried reducing
it further, I ended up removing the problem. Thanks.
I'm willing to agree that that I've have an error/ambiguity in my
code. But I don't understand why bringing in a namespace that isn't
being called should change the ambiguity status. In other
words,
main()
{
using namespace foo;
/* ... */ // no error
}
doesn't generate an error. Neither does:
main()
{
/* ... */ // no error
}
But, the following does generate an error:
using namespace foo;
main()
{
/* ... */ // generates error
}
It seems that the first and the 3rd should be the same. So maybe the
problem is that the third one is correct and that the first two should
catch the ambigity? Or is my understanding of namespaces incorrect?
later,
dean
=============================================================================
Dean Foster dean@foster.net
Statistics, Wharton, U. Penn 215 898 8233
Philadelphia PA 19104-6340 http://diskworld.wharton.upenn.edu
> Date: 21 Apr 2003 15:06:07 -0000
> From: bangerth@dealii.org
> Reply-To: bangerth@dealii.org, dean@foster.net, gcc-bugs@gcc.gnu.org,
> gcc-prs@gcc.gnu.org, nobody@gcc.gnu.org, gcc-gnats@gcc.gnu.org
> X-SBRule: Spammy To: Header
> X-SBRule: Other Spammy Headers
>
> Synopsis: "using namespace" at global scope creates incorrect code
>
> State-Changed-From-To: open->closed
> State-Changed-By: bangerth
> State-Changed-When: Mon Apr 21 15:06:06 2003
> State-Changed-Why:
> I don't think this is a bug. After quite some reducing,
> your code looks like this:
> ---------------------------
> struct X {
> int operator-(const X& it);
> };
>
> template <class T>
> struct Y {
> typedef typename T::SOME_TYPE SOME_TYPE;
> typedef int type;
> };
>
> #ifdef BUG
> template <class T> typename Y<T>::type operator-(T,T);
> #endif
>
> int x = X() - X();
> -----------------------------
> (I replaced your using directive by the conditional
> statement -- both just bring into visibility the
> operator-.)
>
> What happens is that in the minus statement (which was
> inside a std:: function in your example), both possible
> operator- are considered, i.e. the member function and
> the global one. The global one requires instantiation
> of Y, at which point we realize that X::SOME_TYPE does
> not exist:
> g/x> /home/bangerth/bin/gcc-3.4-pre/bin/c++ -c x.cc -DBUG
> x.cc: In instantiation of `Y<X>':
> x.cc:15: instantiated from here
> x.cc:7: error: no type named `SOME_TYPE' in `struct X'
>
> Tracing back where this happens in your code is a little
> more complicated, but I guess this is what happens -- you
> try to use __gnu_cxx::normal_iterator::const_iterator
> when bringing into scope the function in the namespace,
> but this const_iterator doesn't exist.
>
> Wolfgang
>
> http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=10437
>
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: c++/10437: "using namespace" at global scope creates incorrect code
@ 2003-04-21 15:06 bangerth
0 siblings, 0 replies; 6+ messages in thread
From: bangerth @ 2003-04-21 15:06 UTC (permalink / raw)
To: dean, gcc-bugs, gcc-prs, nobody
Synopsis: "using namespace" at global scope creates incorrect code
State-Changed-From-To: open->closed
State-Changed-By: bangerth
State-Changed-When: Mon Apr 21 15:06:06 2003
State-Changed-Why:
I don't think this is a bug. After quite some reducing,
your code looks like this:
---------------------------
struct X {
int operator-(const X& it);
};
template <class T>
struct Y {
typedef typename T::SOME_TYPE SOME_TYPE;
typedef int type;
};
#ifdef BUG
template <class T> typename Y<T>::type operator-(T,T);
#endif
int x = X() - X();
-----------------------------
(I replaced your using directive by the conditional
statement -- both just bring into visibility the
operator-.)
What happens is that in the minus statement (which was
inside a std:: function in your example), both possible
operator- are considered, i.e. the member function and
the global one. The global one requires instantiation
of Y, at which point we realize that X::SOME_TYPE does
not exist:
g/x> /home/bangerth/bin/gcc-3.4-pre/bin/c++ -c x.cc -DBUG
x.cc: In instantiation of `Y<X>':
x.cc:15: instantiated from here
x.cc:7: error: no type named `SOME_TYPE' in `struct X'
Tracing back where this happens in your code is a little
more complicated, but I guess this is what happens -- you
try to use __gnu_cxx::normal_iterator::const_iterator
when bringing into scope the function in the namespace,
but this const_iterator doesn't exist.
Wolfgang
http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=10437
^ permalink raw reply [flat|nested] 6+ messages in thread
* c++/10437: "using namespace" at global scope creates incorrect code
@ 2003-04-19 0:36 dean
0 siblings, 0 replies; 6+ messages in thread
From: dean @ 2003-04-19 0:36 UTC (permalink / raw)
To: gcc-gnats
>Number: 10437
>Category: c++
>Synopsis: "using namespace" at global scope creates incorrect code
>Confidential: no
>Severity: non-critical
>Priority: medium
>Responsible: unassigned
>State: open
>Class: rejects-legal
>Submitter-Id: net
>Arrival-Date: Sat Apr 19 00:36:00 UTC 2003
>Closed-Date:
>Last-Modified:
>Originator: dean@foster.net
>Release: g++ 3.2.2
>Organization:
>Environment:
linux
>Description:
Code compiles differently if it looks like:
using namespace foo;
main()
{
/* ... */
}
VS:
main()
{
using namespace foo;
/* ... */
}
My guess is that templates in the namespace foo are instantiated incorrectly. I'm not totally possitive this is an error, but it seems like either an error in g++, or an error in the definition of how templates should be instantiated.
I cut the file down from several 1000 lines of code to under 400 lines. I'm sorry that I haven't been able to reproduce it with fewer lines of code. But if you look at the last 20 lines of code, I have flagged the troublesome statement.
>How-To-Repeat:
uncomment the line marked that is near the end of the file.
>Fix:
Not a clue!
>Release-Note:
>Audit-Trail:
>Unformatted:
----gnatsweb-attachment----
Content-Type: application/octet-stream; name="namespace_error.cc"
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename="namespace_error.cc"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==
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2003-04-25 19:46 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2003-04-25 19:46 c++/10437: "using namespace" at global scope creates incorrect code Wolfgang Bangerth
-- strict thread matches above, loose matches on Subject: below --
2003-04-25 19:38 bangerth
2003-04-21 20:06 Wolfgang Bangerth
2003-04-21 19:26 Dean Foster
2003-04-21 15:06 bangerth
2003-04-19 0:36 dean
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).