C++: Changing the meaning of a name

We've just bumped the version of gcc we use to build our codebase from 4.2.2 to the shiny, cutting edge 4.3.2. This involved the usual number of small tweaks to our source, to make it compatible with the latest gcc parser.

One change surprised me, though. The following pattern is no longer accepted by gcc:

template <typename T>
class Producer
{
public:
  /// ...
};

template <typename T>
class Consumer
{
public:
  typedef Producer<T> Producer;
};

void ThisWontCompile()
{
  Producer<int> producer;
  Consumer<int> consumer;
}

gcc now generates the following error:

test.cpp:13: error: declaration of 'typedef class Producer Consumer::Producer'
test.cpp:4: error: changes meaning of 'Producer' from 'class Producer'

We use this pattern quite a lot in our code, and it seems reasonably tasteful. Certainly, it seems morally equivalent to the following pattern:

class Foo
{
public:
  /// ...
};

class Bar
{
public:
  void Foo() {}
};

void ThisCompiles()
{
  Bar bar;
}

...in the sense that they both change the meaning of a name within the scope of the second class.

Now I'm no C++ language lawyer, but I've yet to find a compelling part of the standard that shows this to be bad C++ code.

Update

Commenter jd pointed out the solution to this conundrum. The Producer example above will compile if the typedef is written slightly differently, thus:

template <typename T>
class Producer
{
public:
  /// ...
};

template <typename T>
class Consumer
{
public:
   typedef ::Producer<T> Producer;
};

void ThisDoesCompile_Hurrah()
{
  Producer<int> producer;
  Consumer<int> consumer;
}

This shows that the gcc change was not as drastic as I first feared, and the fix is still very valid (and very readable) C++ code.

The problem was gcc looking up the name Producer in the scope of the Consumer class, and finding the Producer typedef name that was in the process of being defined. A subtle problem with a non entirely useful error message (but we're used to those, aren't we?).

Although the other compilers I have tried (MSVC and Comeau) accept the original code, I'm not sure if it is correct according to the letter of the C++ standard or not.