如何使用 YouCompleteMe 在 vi​​m 中启用 C++ 模板类的完成

Question

When using the vim plugin YouCompleteMe for C++ code completion I stumbled over an issue. Using nested template classes stops the completion to work properly.

Consider the following example to reproduce the behaviour:

#include <vector>

template<class T>
class foo {
  public:
  void Init();

  private:
  struct bar {
    int foobar;
  };
  bar one_bar;
  std::vector<foo<T>::bar> some_bars;
};

template<class T>
void foo<T>::Init(){
  one_bar.foobar = 0; // completion as expected
  some_bars.at(0).foobar = 0; // no completion neither for "at" nor for "foobar"
}

The code completion for "some_bars" is not working at all while "one_bar" behaves as expected.

How can I get completion working for this code? Is this issue related to the setup and should actually work or is it a bug in YCM?

My system is debian jessie/sid based, vim version 7.4, YCM latest version from GitHub.

Edit: There are similar issues reported in YCMs bug tracker: https://github.com/Valloric/YouCompleteMe/issues/243 https://github.com/Valloric/YouCompleteMe/issues/530

Seems to be a bug in clang rather than in YCM. Can someone confirm this?

Edit2: I opened another issue in the YCM issue tracker. https://github.com/Valloric/YouCompleteMe/issues/1170

The intention is to get more information on what the bug in clang exactly is and finally to make a bug report in the clang issue tracker.

Edit3: I followed the proposed procedure from RedX and fed my code in clang to get completions. Clang does not provide any suggestions for the discussed positions in the code. This clearly is the reason why YCM fails to make suggestions in vim and it has nothing to do with YCM or vim.

A bug report in the clang issue tracker has been filed: http://llvm.org/bugs/show_bug.cgi?id=20973

Answer 1

I think, under the rules of C++, you cannot get completion in this case.

Without knowledge of the type T , we don't know what methods std::vector<T> will have, as each instansiation of a template in C++ can have different methods.

Answer 2

As @Chris Jefferson mentioned above it is theoretically impossible . This comment doesn't take in account template specializations

In the code shown here, all completions are clearly known, even without knowing the type T. It is not a std::vector but a std::vector<foo::bar>

This occurred to me in a very different context while I was trying to write a specialization for a template without deducting a template.I will provide my example to make the situation clear. So lets say you have an enumerator and you have a meta_info class that defines a size for an enumerator it takes by template so :

enum class e{a,b};
template <class Enum>
struct meta_info;
template<>
meta_info<e>{
    static constexpr size_t s=2;
}

Ok this works and it is nice to have but what happens if you try to do the same thing in an enumerator nested in a template class?

template <class Tag>
struct str{
   enum class e{a,b};
}
template <class Enum>
struct meta_info;
template<T>
meta_info<str<T>::e>{
    static constexpr size_t s=2;
}

This doesn't compile as someone else(another part of the code) might change e with another specialization.There is no formal way for a compiler to know if a specialization changes a type even at the first passes of compilation. Having in mind that auto-complete tools most of the times just use the includes paths to find a suggestion this would be impossible. So in the future I would like to see in ycm something like an informal instantiation like VS has done