This should be streamlined as much as possible with `autocomplete_scope()`, which does mostly the same as what you're trying to achieve, and can probably share some code.

Yeah, looks similar and probably both cases could share some code. This patch works for namespace prefixes only but it could also be changed to work for variable prefixes too (for strongly-typed languages for which we have varType).

On the other hand this patch supports multiple levels of scopes which we don't have in scope completion right now (the code would probably get quite a bit crazier if we were doing scope completion for multiple levels). But maybe it's not so important and one level could be enough.

But yeah, the idea behind the patch makes sense and brings back the beautiful memories of the implementation of scope completion :-).

but once the calltip is shown it no longer respects the scope so well and it just shows all functions.

Yeah, calltips don't look at context AFAIK, only scope autocomplete does, for named scopes (ie classes, namespaces) only, it doesn't know about lexical scopes. And variable scope auto-completion only works for variables defined at top level, so its isn't very useful for modern C/C++.

The whole area could probably use a re-think instead of piling patches over patches, especially if @techee doubts it.

What's the problem with TM? I might be missing something obvious, but a quick and dirty patch like http://pastebin.geany.org/ISAQT/ seems to mostly work.

It could possibly be improved to use the current scope to resolve direct methods and some other stuff, but that could be added. I mean like ```C++ class Foo { std::string something(int n) { return nullptr; }

int main() { return something(/* here, show Foo::something() only, not Bar::something() */); } };

class Bar { int something() { return 0; } };

/* But this works:

Foo::something(); Bar::something();

class Z { Foo memb; Z() { memb.something(); } }; */ ```

@techee yeah, you'll review, and possibly add support for implicitly scoping on `this` :) Although scoping on `this` might be tricky, because you still want to allow global variables and methods. Methods should be fine as the `this` one would have precedence anyway, and we know which it is, but scope completion would have to consider both the `this` scope and the global one in this case.

Ah, and should I PR my quick patch for further discussion/work/whatever, or it's too quick'n dirty do be of any actual use?

Would be good - I'll review and also @krogank9 can check if it works for his use cases.

add support for implicitly scoping on this :)

And @techee can add support for C++ scoping of class members in member functions where _this_ is implicit, so I have less to complain about "every language is C" :)

@b4n, it looked like you are relying on autocomplete's algorithm by cunningly renaming it, but it doesn't work AFAICT, eg:

```c++

struct Bar { int aaab; };

struct Foo { int aaaa; int f(){ aa // now autocomplete shows both aaaa and aaab }; }; ```

Or is that not what its doing.

...

it looked like you are relying on autocomplete's algorithm by cunningly renaming it

what does this mean?

I meant this change:

``` -static gboolean autocomplete_scope(GeanyEditor *editor, const gchar *root, gsize rootlen) +static GPtrArray *get_scoped_tags(GeanyEditor *editor, gint pos) ```

Now my turn :), what do you mean by "only one Foo", the symbol `aaab` is in `Bar` not `Foo`, but it shows for autocomplete inside a member function of `Foo`

Nope, not in current Geany, still both. Or is it some extra magic you added in the patch as well as making scope completion apply to calltips?

Oh, havn't even looked at #1188 yet.