This is the test code (just your ordinary main.cpp) :
#include <iostream>
enum enumerA
{
bla_on,
bla_off
};
enum enumerX
{
bla_on_foo,
bla_off_foo
};
class BitA
{
public:
BitA(){}
void Set(enumerA value) {mValue = value;}
enumerA Get() const {return mValue;}
private:
enumerA mValue;
};
enum enumerB
{
enable,
disable
};
class BitB
{
public:
BitB(){}
void Set(enumerB value) {mValue = value;}
enumerB Get() const {return mValue;}
private:
enumerB mValue;
};
template<typename T>
class BitTemplate
{
public:
BitTemplate() {std::cout << "bit template intended for enums" << std::endl;}
void Set(T value) {mValue = value;}
T Get() const {return mValue;}
private:
T mValue;
};
template<>
class BitTemplate<bool>
{
public:
BitTemplate() {std::cout << "bit template intended for bools" << std::endl;}
void Set(bool value) {mValue = value;}
bool Get() const {return mValue;}
private:
bool mValue;
};
template<>
class BitTemplate<int>
{
public:
BitTemplate() {std::cout << "bit template intended for ints" << std::endl;}
void Set(int value) {mValue = value;}
int Get() const {return mValue;}
private:
int mValue;
};
int main()
{
BitA a;
BitB b;
BitTemplate<enumerA> Bta;
BitTemplate<enumerB> Btb;
BitTemplate<bool> Btbool;
BitTemplate<int> Btint;
return 0;
}
Carry out all experiments on the line before "return 0;"
Issue 1 :
type :
You will see it offers 4 possibilities, but it should only be 2, only the 2 from "enumerA", and not the ones from "enumerX"
Dear killerbot, let me explanation how CC generate the suggestion list.
It is very simple:
1, find the current statement:
for this code:
We just do a backward search from the caret position, then stop at characters like "[" or "(" etc. So, in this case, we stop at "(", so, the actual statement we are interest is:
2, find a initial search scope, Now, we guess the statement "bla_" is in global namespace scope.
3, do a match in the search scope, so all the tokens in the global namespace with a prefix "bla_" will be listed as suggestion list.
From this algorithm, you can see that NO function argument information is used.
Here is another example code:
#include <iostream>
void bla_my_function();
enum enumerA
{
bla_on,
bla_off
};
enum enumerX
{
bla_on_foo,
bla_off_foo
};
class BitA
{
public:
BitA(){}
void Set(enumerA value) {mValue = value;}
enumerA Get() const {return mValue;}
private:
enumerA mValue;
};
BitA a;
a.Set(bla_)
You can see the screen shot, even the global function named "bla_my_function" will be in suggest list:
(http://i683.photobucket.com/albums/vv194/ollydbg_cb/issue1.png)
Solution:
The statement analyzer should be more powerful to detect the caret was locate between parentheses, thus, the function argument type information can be used to filter the suggest result. :D
Currently I have no idea how we can improved it, sure, we can, let me think carefully....