"addr_type" should be marked as warning now. 
Is it marked as error?

We can't completely resolve "addr_type" because we can't make any assumptions about SVC_HANDLER.
It's possible to check all instantiations than take intersection of members of it's template parameters and than match
it with nested type of template parameter inside template definition. 
But this operation could be too time expensive. 
It could be implemented as additional service "Check template instantiations".
Anyway it's enhancement.

A suggestion/question:
Would it be possible to restrict the proposed bindings based on a set of
restrictions? For example:

class TestCase1{
public:
    TestCase1(){}
    ~TestCase1(){}

    void close(void){}
}


class TestCase2{
public:
    TestCase2(){}
    ~TestCase2(){}

    void close(void){}
    int flush(int max){ return 0;}
}



template <class X>
class B1 {
public:
        B1(X* x):m_x(x){}
        virtual ~B1(){}

        void method1(){
           m_x->close();
        }        
protected:
        X m_x;

};

In this case, when we try to "Open declaration" on x->close(), we should be
presented with both TestCase1 & TestCase2.

But if we had the following:
template <class X>
class B2 {
public:
        B2(X* x):m_x(x){}
        virtual ~B2(){}

        void method1(){
           m_x->close();
        }  
        void method2(){
              int ret = m_x->flush(0);
        }       

protected:
        X m_x;

};
Here it would be interesting to only proposal TestCase2 if we try to "Open
declaration" on m_x->flush() or m_x->close(), because it's the only one that
has both methods.

What do you think of this?

I think it's another good enhancement.

But It seems to me that this approach is hard to implement as part of completion or hyperlink.
Completion has about 200 milliseconds. So for big project it would be hard to analyze all possible for instantiation
classes.
Or such data should be recalculated. But I guess such calculation would take a lot of time and memory.

In C++0X there will be special feature Concepts.
http://en.wikipedia.org/wiki/C%2B%2B0x#Concepts

Support of such feature in IDE can solve the problem too.

I think you are right on the C++0X support!

A way to mitigate the problem of long delays, would be with a preference associate with this kind of feature.
If on, then all the calculations would be perform, off otherwise. 
Perhaps with the current development pace of CND (with the improvement of parsing and code model), this won't be a problem.