Merge remote-tracking branch 'origin/2.6'

Conflicts:
	dist/gdb/Makefile.osx
	src/libs/qmldebug/qmldebug.qbs
	src/plugins/android/androidsettingswidget.cpp

Change-Id: I85627130b575f7d08f416dea52031fa72019b217

src/libs/cplusplus/CppRewriter.cpp

@@ -395,7 +395,8 @@ FullySpecifiedType UseMinimalNames::apply(const Name *name, Rewrite *rewrite) co
     SubstitutionEnvironment *env = rewrite->env;
     Scope *scope = env->scope();
 
-    if (name->isTemplateNameId())
+    if (name->isTemplateNameId() ||
+            (name->isQualifiedNameId() && name->asQualifiedNameId()->name()->isTemplateNameId()))
         return FullySpecifiedType();
 
     if (! scope)

src/libs/cplusplus/LookupContext.cpp

@@ -708,11 +708,22 @@ ClassOrNamespace *ClassOrNamespace::nestedType(const Name *name, ClassOrNamespac
     if (!referenceClass)
         return reference;
 
+    const TemplateNameId *templId = name->asTemplateNameId();
+    if (_alreadyConsideredClasses.contains(referenceClass) ||
+            (templId &&
+            _alreadyConsideredTemplates.contains(templId))) {
+            return reference;
+    }
+
+    if (!name->isTemplateNameId())
+        _alreadyConsideredClasses.insert(referenceClass);
+
     QSet<ClassOrNamespace *> knownUsings = reference->usings().toSet();
 
     // If we are dealling with a template type, more work is required, since we need to
     // construct all instantiation data.
-    if (const TemplateNameId *templId = name->asTemplateNameId()) {
+    if (templId) {
+        _alreadyConsideredTemplates.insert(templId);
         ClassOrNamespace *instantiation = _factory->allocClassOrNamespace(reference);
         instantiation->_templateId = templId;
         instantiation->_instantiationOrigin = origin;
@@ -786,18 +797,41 @@ ClassOrNamespace *ClassOrNamespace::nestedType(const Name *name, ClassOrNamespac
             }
         }
 
+        _alreadyConsideredTemplates.clear(templId);
         return instantiation;
     }
 
+    if (allBases.isEmpty() || allBases.size() == knownUsings.size())
+        return reference;
+
+    QList<const Name *> fullyQualifiedNameForReferenceClass =
+            LookupContext::fullyQualifiedName(referenceClass);
     // Find the missing bases for regular (non-template) types.
     // Ex.: class A : public B<Some>::Type {};
     foreach (const Name *baseName, allBases) {
         ClassOrNamespace *binding = this;
         if (const QualifiedNameId *qBaseName = baseName->asQualifiedNameId()) {
+            QList<const Name *> fullyQualifiedNameForBaseClass;
+            addNames(baseName, &fullyQualifiedNameForBaseClass);
+            if (compareFullyQualifiedName(fullyQualifiedNameForReferenceClass,
+                                          fullyQualifiedNameForBaseClass)) {
+                continue;
+            }
+
             if (const Name *qualification = qBaseName->base())
                 binding = lookupType(qualification);
+            else if (binding->parent() != 0)
+                //if this is global identifier we take global namespace
+                //Ex: class A{}; namespace NS { class A: public ::A{}; }
+                binding = binding->globalNamespace();
+            else
+                //if we are in the global scope
+                continue;
             baseName = qBaseName->name();
         }
+        else if (compareName(name, baseName)) {
+            continue;
+        }
 
         if (binding) {
             ClassOrNamespace * baseBinding = binding->lookupType(baseName);
@@ -806,7 +840,7 @@ ClassOrNamespace *ClassOrNamespace::nestedType(const Name *name, ClassOrNamespac
         }
     }
 
-
+    _alreadyConsideredClasses.clear(referenceClass);
     return reference;
 }
 

src/libs/cplusplus/LookupContext.h

@@ -45,6 +45,33 @@
 namespace CPlusPlus {
 
 class CreateBindings;
+class Class;
+template<typename T>
+class AlreadyConsideredClassContainer
+{
+public:
+    AlreadyConsideredClassContainer() : _class(0) {}
+    void insert(const T *item)
+    {
+        if (_container.isEmpty())
+            _class = item;
+        _container.insert(item);
+    }
+    bool contains(const T *item)
+    {
+        return _container.contains(item);
+    }
+
+    void clear(const T *item)
+    {
+        if (_class != item)
+            _container.clear();
+    }
+
+private:
+    QSet<const T *> _container;
+    const T * _class;
+};
 
 class CPLUSPLUS_EXPORT ClassOrNamespace
 {
@@ -112,6 +139,9 @@ private:
     const TemplateNameId *_templateId;
     ClassOrNamespace *_instantiationOrigin;
 
+    AlreadyConsideredClassContainer<Class> _alreadyConsideredClasses;
+    AlreadyConsideredClassContainer<TemplateNameId> _alreadyConsideredTemplates;
+
     friend class CreateBindings;
 };