CEDET

Per Karlström writes:
> I wonder if it is possible to tell semantic about cases where a type is 
> used in a template. For example imagine
>
> template<typename T>
> struct Foo
> {
>    T bar;
>    ...
>    const T& operator->() const {return bar;}
> };
>
> //Some where in code
>
> Foo<SomeType> foo_some_type;
>
> foo_some_type->... (Can semantic resolve what shall come after the ->?)

It can, and it does. The following example works for me:

------------------
template<typename T> struct Foo
{
   T* bar;
   Foo(T* ptr) : bar(ptr) {}
   const T* operator->() const {return bar;}
};

struct SomeType { int a; int b; };

int main(void)
{
   Foo<SomeType> foo_some_type(new SomeType);
   foo_some_type->  // completing here shows 'int a' and 'int b'
}
-------------------

Mind you, this only works for pretty simple cases like the one
above. Doing this for classes like Boost smart pointers will probably
not work, but for other reasons than the overloaded -> operator.

-David

On Mon, Oct 29, 2012 at 2:16 PM, David Engster <deng@...> wrote:

> Mind you, this only works for pretty simple cases like the one
> above. Doing this for classes like Boost smart pointers will probably
> not work, but for other reasons than the overloaded -> operator.

Would that be lack of support for Argument Dependent Name Lookup
(a.k.a Koenig lookup,
http://en.wikipedia.org/wiki/Argument-dependent_name_lookup)?

/john

John Yates writes:
> On Mon, Oct 29, 2012 at 2:16 PM, David Engster <deng@...> wrote:
>
>> Mind you, this only works for pretty simple cases like the one
>> above. Doing this for classes like Boost smart pointers will probably
>> not work, but for other reasons than the overloaded -> operator.
>
> Would that be lack of support for Argument Dependent Name Lookup
> (a.k.a Koenig lookup,
> http://en.wikipedia.org/wiki/Argument-dependent_name_lookup)?

Funny thing is: if you copy&paste that first example on that wiki page,
you'll see that Semantic will show you the correct definition of
'f'. That of course is simply because Semantic will resort to pretty
much everything if it cannot find something in the current scope. We do
not have an explicit ADL implementation.

The usual reason why Semantic cannot parse stuff in the STL or Boost is
because of moderate template trickery, like (partial) template
specializations or the 'rebind' idiom used for allocators. This for
example is the reason why Semantic cannot properly dereference the
[]-operator of the vector class.

-David