C++: Ignore explicit template instantiations

Defined in section 14.7.2 of the standard.

Fixes completion for std::string.

The following explicit instantiation appears in bits/basic_string.tcc:
  extern template class basic_string<char>;

This is wrongfully considered a specialization for a forward declaration
(like `template<> class basic_string<char>` is).

Introduce a new Symbol type for explicit instantiations.

Use-case:
template<class T>
struct Foo { T bar; };

template class Foo<int>;

void func()
{
    Foo<int> foo;
    foo.bar; // bar not highlighted
}

Change-Id: I9e35c8c32f6b78fc87b4f4f1fc903b42cfbd2c2b
Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>

1 files changed, 52 insertions, 0 deletions

diff --git a/src/libs/3rdparty/cplusplus/Symbols.cpp b/src/libs/3rdparty/cplusplus/Symbols.cpp
index f8a8440c09..3c632f1cd7 100644
--- a/src/libs/3rdparty/cplusplus/Symbols.cpp
+++ b/src/libs/3rdparty/cplusplus/Symbols.cpp
@@ -481,10 +481,12 @@ void Enum::visitSymbol0(SymbolVisitor *visitor)
 
 Template::Template(TranslationUnit *translationUnit, unsigned sourceLocation, const Name *name)
     : Scope(translationUnit, sourceLocation, name)
+    , _isExplicitInstantiation(false)
 { }
 
 Template::Template(Clone *clone, Subst *subst, Template *original)
     : Scope(clone, subst, original)
+    , _isExplicitInstantiation(original->_isExplicitInstantiation)
 { }
 
 Template::~Template()
@@ -537,6 +539,56 @@ bool Template::match0(const Type *otherType, Matcher *matcher) const
     return false;
 }
 
+ExplicitInstantiation::ExplicitInstantiation(TranslationUnit *translationUnit,
+                                             unsigned sourceLocation, const Name *name)
+    : Scope(translationUnit, sourceLocation, name)
+{ }
+
+ExplicitInstantiation::ExplicitInstantiation(Clone *clone, Subst *subst, ExplicitInstantiation *original)
+    : Scope(clone, subst, original)
+{ }
+
+ExplicitInstantiation::~ExplicitInstantiation()
+{ }
+
+Symbol *ExplicitInstantiation::declaration() const
+{
+    if (isEmpty())
+        return 0;
+
+    if (Symbol *s = memberAt(memberCount() - 1)) {
+        if (s->isClass() || s->isForwardClassDeclaration() ||
+            s->isTemplate() || s->isExplicitInstantiation() ||
+            s->isFunction() || s->isDeclaration()) {
+            return s;
+        }
+    }
+
+    return 0;
+}
+
+FullySpecifiedType ExplicitInstantiation::type() const
+{ return FullySpecifiedType(const_cast<ExplicitInstantiation *>(this)); }
+
+void ExplicitInstantiation::visitSymbol0(SymbolVisitor *visitor)
+{
+    if (visitor->visit(this)) {
+        for (unsigned i = 0; i < memberCount(); ++i) {
+            visitSymbol(memberAt(i), visitor);
+        }
+    }
+}
+
+void ExplicitInstantiation::accept0(TypeVisitor *visitor)
+{ visitor->visit(this); }
+
+bool ExplicitInstantiation::match0(const Type *otherType, Matcher *matcher) const
+{
+    if (const ExplicitInstantiation *otherTy = otherType->asExplicitInstantiationType())
+        return matcher->match(this, otherTy);
+    return false;
+}
+
 Namespace::Namespace(TranslationUnit *translationUnit, unsigned sourceLocation, const Name *name)
     : Scope(translationUnit, sourceLocation, name)
     , _isInline(false)