diff --git a/languages/clang/duchain/unknowndeclarationproblem.cpp b/languages/clang/duchain/unknowndeclarationproblem.cpp
index 90962eea83..f55da21513 100644
--- a/languages/clang/duchain/unknowndeclarationproblem.cpp
+++ b/languages/clang/duchain/unknowndeclarationproblem.cpp
@@ -1,558 +1,558 @@
 /*
  * Copyright 2014 Jørgen Kvalsvik <lycantrophe@lavabit.com>
  * Copyright 2014 Kevin Funk <kfunk@kde.org>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License or (at your option) version 3 or any later version
  * accepted by the membership of KDE e.V. (or its successor approved
  * by the membership of KDE e.V.), which shall act as a proxy
  * defined in Section 14 of version 3 of the license.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #include "unknowndeclarationproblem.h"
 
 #include "clanghelpers.h"
 #include "parsesession.h"
 #include "../util/clangdebug.h"
 #include "../util/clangutils.h"
 #include "../util/clangtypes.h"
 #include "../clangsettings/clangsettingsmanager.h"
 
 #include <interfaces/icore.h>
 #include <interfaces/iprojectcontroller.h>
 #include <interfaces/iproject.h>
 
 #include <language/duchain/persistentsymboltable.h>
 #include <language/duchain/aliasdeclaration.h>
 #include <language/duchain/classdeclaration.h>
 #include <language/duchain/parsingenvironment.h>
 #include <language/duchain/topducontext.h>
 #include <language/duchain/duchainlock.h>
 #include <language/duchain/duchainutils.h>
 #include <languages/plugins/custom-definesandincludes/idefinesandincludesmanager.h>
 
 #include <project/projectmodel.h>
 #include <util/path.h>
 
 #include <KLocalizedString>
 
 #include <QDir>
 #include <QProcess>
 #include <QRegularExpression>
 
 #include <algorithm>
 
 using namespace KDevelop;
 
 namespace {
 /** Under some conditions, such as when looking up suggestions
  * for the undeclared namespace 'std' we will get an awful lot
  * of suggestions. This parameter limits how many suggestions
  * will pop up, as rarely more than a few will be relevant anyways
  *
  * Forward declaration suggestions are included in this number
  */
 const int maxSuggestions = 5;
 
 /**
  * We don't want anything from the bits directory -
  * we'd rather prefer forwarding includes, such as <vector>
  */
 bool isBlacklisted(const QString& path)
 {
     if (ClangHelpers::isSource(path))
         return true;
 
     // Do not allow including directly from the bits directory.
     // Instead use one of the forwarding headers in other directories, when possible.
     if (path.contains( QLatin1String("bits") ) && path.contains(QLatin1String("/include/c++/")))
         return true;
 
     return false;
 }
 
 QStringList scanIncludePaths( const QString& identifier, const QDir& dir, int maxDepth = 3 )
 {
     if (!maxDepth) {
         return {};
     }
 
     QStringList candidates;
     const auto path = dir.absolutePath();
 
     if( isBlacklisted( path ) ) {
         return {};
     }
 
     const QStringList nameFilters = {identifier, identifier + QLatin1String(".*")};
     for (const auto& file : dir.entryList(nameFilters, QDir::Files)) {
         if (identifier.compare(file, Qt::CaseInsensitive) == 0 || ClangHelpers::isHeader(file)) {
             const QString filePath = path + QLatin1Char('/') + file;
             clangDebug() << "Found candidate file" << filePath;
             candidates.append( filePath );
         }
     }
 
     maxDepth--;
     for( const auto& subdir : dir.entryList( QDir::Dirs | QDir::NoDotAndDotDot ) )
         candidates += scanIncludePaths( identifier, QDir{ path + QLatin1Char('/') + subdir }, maxDepth );
 
     return candidates;
 }
 
 /**
  * Find files in dir that match the given identifier. Matches common C++ header file extensions only.
  */
 QStringList scanIncludePaths( const QualifiedIdentifier& identifier, const KDevelop::Path::List& includes )
 {
     const auto stripped_identifier = identifier.last().toString();
     QStringList candidates;
     for( const auto& include : includes ) {
         candidates += scanIncludePaths( stripped_identifier, QDir{ include.toLocalFile() } );
     }
 
     std::sort( candidates.begin(), candidates.end() );
     candidates.erase( std::unique( candidates.begin(), candidates.end() ), candidates.end() );
     return candidates;
 }
 
 /**
  * Determine how much path is shared between two includes.
  *  boost/tr1/unordered_map
  *  boost/tr1/unordered_set
  * have a shared path of 2 where
  *  boost/tr1/unordered_map
  *  boost/vector
  * have a shared path of 1
  */
 int sharedPathLevel(const QString& a, const QString& b)
 {
     int shared = -1;
     for(auto x = a.begin(), y = b.begin(); *x == *y && x != a.end() && y != b.end() ; ++x, ++y ) {
         if( *x == QDir::separator() ) {
             ++shared;
         }
     }
 
     return shared;
 }
 
 /**
  * Try to find a proper include position from the DUChain:
  *
  * look at existing imports (i.e. #include's) and find a fitting
  * file with the same/similar path to the new include file and use that
  *
  * TODO: Implement a fallback scheme
  */
 KDevelop::DocumentRange includeDirectivePosition(const KDevelop::Path& source, const QString& includeFile)
 {
     static const QRegularExpression mocFilenameExpression(QStringLiteral("(moc_[^\\/\\\\]+\\.cpp$|\\.moc$)") );
 
     DUChainReadLocker lock;
     const TopDUContext* top = DUChainUtils::standardContextForUrl( source.toUrl() );
     if( !top ) {
         clangDebug() << "unable to find standard context for" << source.toLocalFile() << "Creating null range";
         return KDevelop::DocumentRange::invalid();
     }
 
     int line = -1;
 
     // look at existing #include statements and re-use them
     int currentMatchQuality = -1;
     for( const auto& import : top->importedParentContexts() ) {
 
         const auto importFilename = import.context(top)->url().str();
         const int matchQuality = sharedPathLevel( importFilename , includeFile );
         if( matchQuality < currentMatchQuality ) {
             continue;
         }
 
         const auto match = mocFilenameExpression.match(importFilename);
-        if (match.isValid()) {
+        if (match.hasMatch()) {
             clangDebug() << "moc file detected in" << source.toUrl().toDisplayString() << ":" << importFilename << "-- not using as include insertion location";
             continue;
         }
 
         line = import.position.line + 1;
         currentMatchQuality = matchQuality;
     }
 
     if( line == -1 ) {
         /* Insert at the top of the document */
         return {IndexedString(source.pathOrUrl()), {0, 0, 0, 0}};
     }
 
     return {IndexedString(source.pathOrUrl()), {line, 0, line, 0}};
 }
 
 KDevelop::DocumentRange forwardDeclarationPosition(const QualifiedIdentifier& identifier, const KDevelop::Path& source)
 {
     DUChainReadLocker lock;
     const TopDUContext* top = DUChainUtils::standardContextForUrl( source.toUrl() );
     if( !top ) {
         clangDebug() << "unable to find standard context for" << source.toLocalFile() << "Creating null range";
         return KDevelop::DocumentRange::invalid();
     }
 
     if (!top->findDeclarations(identifier).isEmpty()) {
         // Already forward-declared
         return KDevelop::DocumentRange::invalid();
     }
 
     int line = std::numeric_limits< int >::max();
     for( const auto decl : top->localDeclarations() ) {
         line = std::min( line, decl->range().start.line );
     }
 
     if( line == std::numeric_limits< int >::max() ) {
         return KDevelop::DocumentRange::invalid();
     }
 
     // We want it one line above the first declaration
     line = std::max( line - 1, 0 );
 
     return {IndexedString(source.pathOrUrl()), {line, 0, line, 0}};
 }
 
 /**
  * Iteratively build all levels of the current scope. A (missing) type anywhere
  * can be arbitrarily namespaced, so we create the permutations of possible
  * nestings of namespaces it can currently be in,
  *
  * TODO: add detection of namespace aliases, such as 'using namespace KDevelop;'
  *
  * namespace foo {
  *      namespace bar {
  *          function baz() {
  *              type var;
  *          }
  *      }
  * }
  *
  * Would give:
  * foo::bar::baz::type
  * foo::bar::type
  * foo::type
  * type
  */
 QVector<KDevelop::QualifiedIdentifier> findPossibleQualifiedIdentifiers( const QualifiedIdentifier& identifier, const KDevelop::Path& file, const KDevelop::CursorInRevision& cursor )
 {
     DUChainReadLocker lock;
     const TopDUContext* top = DUChainUtils::standardContextForUrl( file.toUrl() );
 
     if( !top ) {
         clangDebug() << "unable to find standard context for" << file.toLocalFile() << "Not creating duchain candidates";
         return {};
     }
 
     const auto* context = top->findContextAt( cursor );
     if( !context ) {
         clangDebug() << "No context found at" << cursor;
         return {};
     }
 
     QVector<KDevelop::QualifiedIdentifier> declarations{ identifier };
     for( auto scopes = context->scopeIdentifier(); !scopes.isEmpty(); scopes.pop() ) {
         declarations.append( scopes + identifier );
     }
 
     clangDebug() << "Possible declarations:" << declarations;
     return declarations;
 }
 
 }
 
 QStringList UnknownDeclarationProblem::findMatchingIncludeFiles(const QVector<Declaration*>& declarations)
 {
     DUChainReadLocker lock;
 
     QStringList candidates;
     for (const auto decl: declarations) {
         // skip declarations that don't belong to us
         const auto& file = decl->topContext()->parsingEnvironmentFile();
         if (!file || file->language() != ParseSession::languageString()) {
             continue;
         }
 
         if( dynamic_cast<KDevelop::AliasDeclaration*>( decl ) ) {
             continue;
         }
 
         if( decl->isForwardDeclaration() ) {
             continue;
         }
 
         const auto filepath = decl->url().toUrl().toLocalFile();
 
         if( !isBlacklisted( filepath ) ) {
             candidates << filepath;
             clangDebug() << "Adding" << filepath << "determined from candidate" << decl->toString();
         }
 
         for( const auto importer : file->importers() ) {
             if( importer->imports().count() != 1 && !isBlacklisted( filepath ) ) {
                 continue;
             }
             if( importer->topContext()->localDeclarations().count() ) {
                 continue;
             }
 
             const auto filePath = importer->url().toUrl().toLocalFile();
             if( isBlacklisted( filePath ) ) {
                 continue;
             }
 
             /* This file is a forwarder, such as <vector>
              * <vector> does not actually implement the functions, but include other headers that do
              * we prefer this to other headers
              */
             candidates << filePath;
             clangDebug() << "Adding forwarder file" << filePath << "to the result set";
         }
     }
 
     std::sort( candidates.begin(), candidates.end() );
     candidates.erase( std::unique( candidates.begin(), candidates.end() ), candidates.end() );
     clangDebug() << "Candidates: " << candidates;
     return candidates;
 }
 
 namespace {
 
 /**
  * Takes a filepath and the include paths and determines what directive to use.
  */
 ClangFixit directiveForFile( const QString& includefile, const KDevelop::Path::List& includepaths, const KDevelop::Path& source )
 {
     const auto sourceFolder = source.parent();
     const Path canonicalFile( QFileInfo( includefile ).canonicalFilePath() );
 
     QString shortestDirective;
     bool isRelative = false;
 
     // we can include the file directly
     if (sourceFolder == canonicalFile.parent()) {
         shortestDirective = canonicalFile.lastPathSegment();
         isRelative = true;
     } else {
         // find the include directive with the shortest length
         for( const auto& includePath : includepaths ) {
             QString relative = includePath.relativePath( canonicalFile );
             if( relative.startsWith( QLatin1String("./") ) )
                 relative = relative.mid( 2 );
 
             if( shortestDirective.isEmpty() || relative.length() < shortestDirective.length() ) {
                 shortestDirective = relative;
                 isRelative = includePath == sourceFolder;
             }
         }
     }
 
     if( shortestDirective.isEmpty() ) {
         // Item not found in include path
         return {};
     }
 
     const auto range = DocumentRange(IndexedString(source.pathOrUrl()), includeDirectivePosition(source, canonicalFile.lastPathSegment()));
     if( !range.isValid() ) {
         clangDebug() << "unable to determine valid position for" << includefile << "in" << source.pathOrUrl();
         return {};
     }
 
     QString directive;
     if( isRelative ) {
         directive = QStringLiteral("#include \"%1\"").arg(shortestDirective);
     } else {
         directive = QStringLiteral("#include <%1>").arg(shortestDirective);
     }
     return ClangFixit{directive + QLatin1Char('\n'), range, i18n("Insert \'%1\'", directive)};
 }
 
 KDevelop::Path::List includePaths( const KDevelop::Path& file )
 {
     // Find project's custom include paths
     const auto source = file.toLocalFile();
     const auto item = ICore::self()->projectController()->projectModel()->itemForPath( KDevelop::IndexedString( source ) );
 
     return IDefinesAndIncludesManager::manager()->includes(item);
 }
 
 /**
  * Return a list of header files viable for inclusions. All elements will be unique
  */
 QStringList includeFiles(const QualifiedIdentifier& identifier, const QVector<Declaration*> declarations, const KDevelop::Path& file)
 {
     const auto includes = includePaths( file );
     if( includes.isEmpty() ) {
         clangDebug() << "Include path is empty";
         return {};
     }
 
     const auto candidates = UnknownDeclarationProblem::findMatchingIncludeFiles(declarations);
     if( !candidates.isEmpty() ) {
         // If we find a candidate from the duchain we don't bother scanning the include paths
         return candidates;
     }
 
     return scanIncludePaths(identifier, includes);
 }
 
 /**
  * Construct viable forward declarations for the type name.
  */
 ClangFixits forwardDeclarations(const QVector<Declaration*>& matchingDeclarations, const Path& source)
 {
     DUChainReadLocker lock;
     ClangFixits fixits;
     for (const auto decl : matchingDeclarations) {
         const auto qid = decl->qualifiedIdentifier();
 
         if (qid.count() > 1) {
             // TODO: Currently we're not able to determine what is namespaces, class names etc
             // and makes a suitable forward declaration, so just suggest "vanilla" declarations.
             continue;
         }
 
         const auto range = forwardDeclarationPosition(qid, source);
         if (!range.isValid()) {
             continue; // do not know where to insert
         }
 
         if (const auto classDecl = dynamic_cast<ClassDeclaration*>(decl)) {
             const auto name = qid.last().toString();
 
             switch (classDecl->classType()) {
             case ClassDeclarationData::Class:
                 fixits += {
                     QLatin1String("class ") + name + QLatin1String(";\n"), range,
                     i18n("Forward declare as 'class'")
                 };
                 break;
             case ClassDeclarationData::Struct:
                 fixits += {
                     QLatin1String("struct ") + name + QLatin1String(";\n"), range,
                     i18n("Forward declare as 'struct'")
                 };
                 break;
             default:
                 break;
             }
         }
     }
     return fixits;
 }
 
 /**
  * Search the persistent symbol table for matching declarations for identifiers @p identifiers
  */
 QVector<Declaration*> findMatchingDeclarations(const QVector<QualifiedIdentifier>& identifiers)
 {
     DUChainReadLocker lock;
 
     QVector<Declaration*> matchingDeclarations;
     matchingDeclarations.reserve(identifiers.size());
     for (const auto& declaration : identifiers) {
         clangDebug() << "Considering candidate declaration" << declaration;
         const IndexedDeclaration* declarations;
         uint declarationCount;
         PersistentSymbolTable::self().declarations( declaration , declarationCount, declarations );
 
         for (uint i = 0; i < declarationCount; ++i) {
             // Skip if the declaration is invalid or if it is an alias declaration -
             // we want the actual declaration (and its file)
             if (auto decl = declarations[i].declaration()) {
                 matchingDeclarations << decl;
             }
         }
     }
     return matchingDeclarations;
 }
 
 ClangFixits fixUnknownDeclaration( const QualifiedIdentifier& identifier, const KDevelop::Path& file, const KDevelop::DocumentRange& docrange )
 {
     ClangFixits fixits;
 
     const CursorInRevision cursor{docrange.start().line(), docrange.start().column()};
 
     const auto possibleIdentifiers = findPossibleQualifiedIdentifiers(identifier, file, cursor);
     const auto matchingDeclarations = findMatchingDeclarations(possibleIdentifiers);
 
     if (ClangSettingsManager::self()->assistantsSettings().forwardDeclare) {
         for (const auto& fixit : forwardDeclarations(matchingDeclarations, file)) {
             fixits << fixit;
             if (fixits.size() == maxSuggestions) {
                 return fixits;
             }
         }
     }
 
     const auto includefiles = includeFiles(identifier, matchingDeclarations, file);
     if (includefiles.isEmpty()) {
         // return early as the computation of the include paths is quite expensive
         return fixits;
     }
 
     const auto includepaths = includePaths( file );
     clangDebug() << "found include paths for" << file << ":" << includepaths;
 
     /* create fixits for candidates */
     for( const auto& includeFile : includefiles ) {
         const auto fixit = directiveForFile( includeFile, includepaths, file /* UP */ );
         if (!fixit.range.isValid()) {
             clangDebug() << "unable to create directive for" << includeFile << "in" << file.toLocalFile();
             continue;
         }
 
         fixits << fixit;
 
         if (fixits.size() == maxSuggestions) {
             return fixits;
         }
     }
 
     return fixits;
 }
 
 QString symbolFromDiagnosticSpelling(const QString& str)
 {
     /* in all error messages the symbol is in in the first pair of quotes */
     const auto split = str.split( QLatin1Char('\'') );
     auto symbol = split.value( 1 );
 
     if( str.startsWith( QLatin1String("No member named") ) ) {
         symbol = split.value( 3 ) + QLatin1String("::") + split.value( 1 );
     }
     return symbol;
 }
 
 }
 
 UnknownDeclarationProblem::UnknownDeclarationProblem(CXDiagnostic diagnostic, CXTranslationUnit unit)
     : ClangProblem(diagnostic, unit)
 {
     setSymbol(QualifiedIdentifier(symbolFromDiagnosticSpelling(description())));
 }
 
 void UnknownDeclarationProblem::setSymbol(const QualifiedIdentifier& identifier)
 {
     m_identifier = identifier;
 }
 
 IAssistant::Ptr UnknownDeclarationProblem::solutionAssistant() const
 {
     const Path path(finalLocation().document.str());
     const auto fixits = allFixits() + fixUnknownDeclaration(m_identifier, path, finalLocation());
     return IAssistant::Ptr(new ClangFixitAssistant(fixits));
 }
diff --git a/languages/clang/tests/test_problems.cpp b/languages/clang/tests/test_problems.cpp
index 21313f1ca8..98128b0256 100644
--- a/languages/clang/tests/test_problems.cpp
+++ b/languages/clang/tests/test_problems.cpp
@@ -1,508 +1,508 @@
 /*************************************************************************************
  *  Copyright (C) Kevin Funk <kfunk@kde.org>                                         *
  *                                                                                   *
  *  This program is free software; you can redistribute it and/or                    *
  *  modify it under the terms of the GNU General Public License                      *
  *  as published by the Free Software Foundation; either version 2                   *
  *  of the License, or (at your option) any later version.                           *
  *                                                                                   *
  *  This program is distributed in the hope that it will be useful,                  *
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of                   *
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                    *
  *  GNU General Public License for more details.                                     *
  *                                                                                   *
  *  You should have received a copy of the GNU General Public License                *
  *  along with this program; if not, write to the Free Software                      *
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA   *
  *************************************************************************************/
 
 #include "test_problems.h"
 
 #include "../duchain/clangindex.h"
 #include "../duchain/clangproblem.h"
 #include "../duchain/parsesession.h"
 #include "../duchain/unknowndeclarationproblem.h"
 #include "../util/clangtypes.h"
 
 #include <language/duchain/duchain.h>
 #include <language/duchain/duchainutils.h>
 #include <language/duchain/duchainlock.h>
 #include <language/codegen/coderepresentation.h>
 #include <language/backgroundparser/backgroundparser.h>
 
 #include <tests/autotestshell.h>
 #include <tests/testcore.h>
 #include <tests/testfile.h>
 #include <tests/testhelpers.h>
 #include <tests/testproject.h>
 #include <interfaces/ilanguagecontroller.h>
 
 #include <QtTest/QTest>
 #include <QLoggingCategory>
 
 #include <ktexteditor_version.h>
 #if KTEXTEDITOR_VERSION < QT_VERSION_CHECK(5, 10, 0)
 Q_DECLARE_METATYPE(KTextEditor::Cursor);
 Q_DECLARE_METATYPE(KTextEditor::Range);
 #endif
 
 Q_DECLARE_METATYPE(KDevelop::IProblem::Severity);
 
 using namespace KDevelop;
 
 namespace {
 
 const QString FileName = 
 #ifdef Q_OS_WIN
     QStringLiteral("C:/tmp/stdin.cpp");
 #else
     QStringLiteral("/tmp/stdin.cpp");
 #endif
 
 QList<ProblemPointer> parse(const QByteArray& code)
 {
     ClangIndex index;
     ClangParsingEnvironment environment;
     environment.setTranslationUnitUrl(IndexedString(FileName));
     ParseSession session(ParseSessionData::Ptr(new ParseSessionData({UnsavedFile(FileName, {code})},
                                                                     &index, environment)));
     return session.problemsForFile(session.mainFile());
 }
 
 void compareFixitWithoutDescription(const ClangFixit& a, const ClangFixit& b)
 {
     QCOMPARE(a.replacementText, b.replacementText);
     QCOMPARE(a.range, b.range);
     QCOMPARE(a.currentText, b.currentText);
 }
 
 void compareFixitsWithoutDescription(const ClangFixits& a, const ClangFixits& b)
 {
     QCOMPARE(a.size(), b.size());
     const int size = a.size();
     for (int i = 0; i < size; ++i) {
         compareFixitWithoutDescription(a.at(i), b.at(i));
     }
 }
 
 }
 
 QTEST_GUILESS_MAIN(TestProblems)
 
 void TestProblems::initTestCase()
 {
     QLoggingCategory::setFilterRules(QStringLiteral("*.debug=false\ndefault.debug=true\nkdevelop.plugins.clang.debug=true\n"));
     QVERIFY(qputenv("KDEV_CLANG_DISPLAY_DIAGS", "1"));
     AutoTestShell::init({"kdevclangsupport"});
     TestCore::initialize(Core::NoUi);
     DUChain::self()->disablePersistentStorage();
     Core::self()->languageController()->backgroundParser()->setDelay(0);
     CodeRepresentation::setDiskChangesForbidden(true);
 }
 
 void TestProblems::cleanupTestCase()
 {
     TestCore::shutdown();
 }
 
 void TestProblems::testNoProblems()
 {
     const QByteArray code = "int main() {}";
     auto problems = parse(code);
     QCOMPARE(problems.size(), 0);
 }
 
 void TestProblems::testBasicProblems()
 {
     // expected:
     // <stdin>:1:13: error: expected ';' after class
     // class Foo {}
     //             ^
     //             ;
     const QByteArray code = "class Foo {}";
     auto problems = parse(code);
     QCOMPARE(problems.size(), 1);
     QCOMPARE(problems[0]->diagnostics().size(), 0);
     auto range = problems[0]->rangeInCurrentRevision();
     QCOMPARE(range.start(), KTextEditor::Cursor(0, 12));
     QCOMPARE(range.end(), KTextEditor::Cursor(0, 12));
 }
 
 void TestProblems::testBasicRangeSupport()
 {
     // expected:
     // <stdin>:1:17: warning: expression result unused [-Wunused-value]
     // int main() { (1 + 1); }
     //               ~ ^ ~
     const QByteArray code = "int main() { (1 + 1); }";
     auto problems = parse(code);
     QCOMPARE(problems.size(), 1);
     QCOMPARE(problems[0]->diagnostics().size(), 0);
     auto range = problems[0]->rangeInCurrentRevision();
     QCOMPARE(range.start(), KTextEditor::Cursor(0, 14));
     QCOMPARE(range.end(), KTextEditor::Cursor(0, 19));
 }
 
 void TestProblems::testChildDiagnostics()
 {
     // expected:
     // test.cpp:3:14: error: call to 'foo' is ambiguous
     // int main() { foo(0); }
     //              ^~~
     // test.cpp:1:6: note: candidate function
     // void foo(unsigned int);
     //      ^
     // test.cpp:2:6: note: candidate function
     // void foo(const char*);
     //      ^
     const QByteArray code = "void foo(unsigned int);\n"
                             "void foo(const char*);\n"
                             "int main() { foo(0); }";
     auto problems = parse(code);
     QCOMPARE(problems.size(), 1);
     auto range = problems[0]->rangeInCurrentRevision();
     QCOMPARE(range.start(), KTextEditor::Cursor(2, 13));
     QCOMPARE(range.end(), KTextEditor::Cursor(2, 16));
     QCOMPARE(problems[0]->diagnostics().size(), 2);
     IProblem::Ptr p1 = problems[0]->diagnostics()[0];
     const ProblemPointer d1 = ProblemPointer(dynamic_cast<Problem*>(p1.data()));
     QCOMPARE(d1->url().str(), FileName);
     QCOMPARE(d1->rangeInCurrentRevision(), KTextEditor::Range(0, 5, 0, 8));
     IProblem::Ptr p2 = problems[0]->diagnostics()[1];
     const ProblemPointer d2 = ProblemPointer(dynamic_cast<Problem*>(p2.data()));
     QCOMPARE(d2->url().str(), FileName);
     QCOMPARE(d2->rangeInCurrentRevision(), KTextEditor::Range(1, 5, 1, 8));
 }
 
 Q_DECLARE_METATYPE(QVector<ClangFixit>);
 
 /**
  * Provides a list of possible fixits: http://blog.llvm.org/2010/04/amazing-feats-of-clang-error-recovery.html
  */
 void TestProblems::testFixits()
 {
     QFETCH(QString, code);
     QFETCH(int, problemsCount);
     QFETCH(QVector<ClangFixit>, fixits);
 
     auto problems = parse(code.toLatin1());
 
     qDebug() << problems.last()->description();
     QCOMPARE(problems.size(), problemsCount);
 
     const ClangProblem* p1 = dynamic_cast<ClangProblem*>(problems[0].data());
     QVERIFY(p1);
     ClangFixitAssistant* a1 = qobject_cast<ClangFixitAssistant*>(p1->solutionAssistant().data());
     QVERIFY(a1);
 
     QCOMPARE(p1->allFixits(), fixits);
 }
 
 void TestProblems::testFixits_data()
 {
     QTest::addColumn<QString>("code"); // input
     QTest::addColumn<int>("problemsCount");
     QTest::addColumn<QVector<ClangFixit>>("fixits");
 
     // expected:
     // test -Wextra-tokens
     // /home/krf/test.cpp:2:8: warning: extra tokens at end of #endif directive [-Wextra-tokens]
     // #endif FOO
     //        ^
     //        //
     QTest::newRow("extra-tokens test")
         << "#ifdef FOO\n#endif FOO\n"
         << 1
         << QVector<ClangFixit>{ ClangFixit{"//", DocumentRange(IndexedString(FileName), KTextEditor::Range(1, 7, 1, 7)), QString()} };
 
     // expected:
     // test.cpp:1:19: warning: empty parentheses interpreted as a function declaration [-Wvexing-parse]
     //     int a();
     //          ^~
     // test.cpp:1:19: note: replace parentheses with an initializer to declare a variable
     //     int a();
     //          ^~
     //           = 0
     QTest::newRow("vexing-parse test")
         << "int main() { int a(); }\n"
         << 1
         << QVector<ClangFixit>{ ClangFixit{" = 0", DocumentRange(IndexedString(FileName), KTextEditor::Range(0, 18, 0, 20)), QString()} };
 
     // expected:
     // test.cpp:2:21: error: no member named 'someVariablf' in 'C'; did you mean 'someVariable'?
     // int main() { C c; c.someVariablf = 1; }
     //                     ^~~~~~~~~~~~
     //                     someVariable
     QTest::newRow("spell-check test")
         << "class C{ int someVariable; };\n"
            "int main() { C c; c.someVariablf = 1; }\n"
         << 1
         << QVector<ClangFixit>{ ClangFixit{"someVariable", DocumentRange(IndexedString(FileName), KTextEditor::Range(1, 20, 1, 32)), QString()} };
 }
 
 struct Replacement
 {
     QString string;
     QString replacement;
 };
 using Replacements = QVector<Replacement>;
 
 ClangFixits resolveFilenames(const ClangFixits& fixits, const Replacements& replacements)
 {
     ClangFixits ret;
     for (const auto& fixit : fixits) {
         ClangFixit copy = fixit;
         for (const auto& replacement : replacements) {
             copy.replacementText.replace(replacement.string, replacement.replacement);
             copy.range.document = IndexedString(copy.range.document.str().replace(replacement.string, replacement.replacement));
         }
         ret << copy;
     }
     return ret;
 }
 
 void TestProblems::testMissingInclude()
 {
     QFETCH(QString, includeFileContent);
     QFETCH(QString, workingFileContent);
     QFETCH(QString, dummyFileName);
     QFETCH(QVector<ClangFixit>, fixits);
 
     TestFile include(includeFileContent, "h");
     include.parse(TopDUContext::AllDeclarationsAndContexts);
 
     QScopedPointer<QTemporaryFile> dummyFile;
     if (!dummyFileName.isEmpty()) {
         dummyFile.reset(new QTemporaryFile(QDir::tempPath() + dummyFileName));
         QVERIFY(dummyFile->open());
 
         workingFileContent.replace("dummyInclude", dummyFile->fileName());
     }
 
     TestFile workingFile(workingFileContent, "cpp");
     workingFile.parse(TopDUContext::AllDeclarationsAndContexts);
 
     QCOMPARE(include.url().toUrl().adjusted(QUrl::RemoveFilename), workingFile.url().toUrl().adjusted(QUrl::RemoveFilename));
     QVERIFY(include.waitForParsed());
     QVERIFY(workingFile.waitForParsed());
 
     DUChainReadLocker lock;
 
     QVERIFY(include.topContext());
     TopDUContext* includeTop = DUChainUtils::contentContextFromProxyContext(include.topContext().data());
     QVERIFY(includeTop);
 
     QVERIFY(workingFile.topContext());
     TopDUContext* top = DUChainUtils::contentContextFromProxyContext(workingFile.topContext());
     QVERIFY(top);
     QCOMPARE(top->problems().size(), 1);
 
     auto problem = dynamic_cast<UnknownDeclarationProblem*>(top->problems().first().data());
     auto assistant = problem->solutionAssistant();
     auto clangFixitAssistant = qobject_cast<ClangFixitAssistant*>(assistant.data());
     QVERIFY(clangFixitAssistant);
 
     auto resolvedFixits = resolveFilenames(fixits, {
        {"includeFile.h", include.url().toUrl().fileName()},
        {"workingFile.h", workingFile.url().toUrl().fileName()}
     });
     compareFixitsWithoutDescription(clangFixitAssistant->fixits(), resolvedFixits);
 }
 
 void TestProblems::testMissingInclude_data()
 {
     QTest::addColumn<QString>("includeFileContent");
     QTest::addColumn<QString>("workingFileContent");
     QTest::addColumn<QString>("dummyFileName");
     QTest::addColumn<QVector<ClangFixit>>("fixits");
 
     QTest::newRow("basic")
         << "class A {};\n"
         << "int main() { A a; }\n"
         << QString()
         << QVector<ClangFixit>{
             ClangFixit{"class A;\n", DocumentRange(IndexedString(QDir::tempPath() + "/workingFile.h"), KTextEditor::Range(0, 0, 0, 0)), QString()},
             ClangFixit{"#include \"includeFile.h\"\n", DocumentRange(IndexedString(QDir::tempPath() + "/workingFile.h"), KTextEditor::Range(0, 0, 0, 0)), QString()}
         };
 
     // cf. bug 375274
     QTest::newRow("ignore-moc-at-end")
         << "class Foo {};\n"
-        << "int main() { Foo foo; }\n#include \"dummyInclude\"\n"
+        << "#include <vector>\nint main() { Foo foo; }\n#include \"dummyInclude\"\n"
         << "/moc_fooXXXXXX.cpp"
         << QVector<ClangFixit>{
             ClangFixit{"class Foo;\n", DocumentRange(IndexedString(QDir::tempPath() + "/workingFile.h"), KTextEditor::Range(0, 0, 0, 0)), QString()},
-            ClangFixit{"#include \"includeFile.h\"\n", DocumentRange(IndexedString(QDir::tempPath() + "/workingFile.h"), KTextEditor::Range(0, 0, 0, 0)), QString()}
+            ClangFixit{"#include \"includeFile.h\"\n", DocumentRange(IndexedString(QDir::tempPath() + "/workingFile.h"), KTextEditor::Range(1, 0, 1, 0)), QString()}
         };
     QTest::newRow("ignore-moc-at-end2")
         << "class Foo {};\n"
         << "int main() { Foo foo; }\n#include \"dummyInclude\"\n"
         << "/fooXXXXXX.moc"
         << QVector<ClangFixit>{
             ClangFixit{"class Foo;\n", DocumentRange(IndexedString(QDir::tempPath() + "/workingFile.h"), KTextEditor::Range(0, 0, 0, 0)), QString()},
             ClangFixit{"#include \"includeFile.h\"\n", DocumentRange(IndexedString(QDir::tempPath() + "/workingFile.h"), KTextEditor::Range(0, 0, 0, 0)), QString()}
         };
 }
 
 struct ExpectedTodo
 {
     QString description;
     KTextEditor::Cursor start;
     KTextEditor::Cursor end;
 };
 typedef QVector<ExpectedTodo> ExpectedTodos;
 Q_DECLARE_METATYPE(ExpectedTodos)
 
 void TestProblems::testTodoProblems()
 {
     QFETCH(QString, code);
     QFETCH(ExpectedTodos, expectedTodos);
 
     TestFile file(code, "cpp");
     QVERIFY(file.parseAndWait());
 
     DUChainReadLocker lock;
     auto top = file.topContext();
     QVERIFY(top);
     auto problems = top->problems();
     QCOMPARE(problems.size(), expectedTodos.size());
 
     for (int i = 0; i < problems.size(); ++i) {
         auto problem = problems[i];
         auto expectedTodo = expectedTodos[i];
         QCOMPARE(problem->description(), expectedTodo.description);
         QCOMPARE(problem->finalLocation().start(), expectedTodo.start);
         QCOMPARE(problem->finalLocation().end(), expectedTodo.end);
     }
 }
 
 void TestProblems::testTodoProblems_data()
 {
     QTest::addColumn<QString>("code");
     QTest::addColumn<ExpectedTodos>("expectedTodos");
 
     // we have two problems here:
     // - we cannot search for comments without declarations,
     //   that means: we can only search inside doxygen-style comments
     //   possible fix: -fparse-all-comments -- however: libclang API is lacking here again.
     //   Can only search through comments attached to a valid entity in the AST
     // - we cannot detect the correct location of the comment yet
     // see more comments inside TodoExtractor
     QTest::newRow("simple1")
         << "/** TODO: Something */\n/** notodo */\n"
         << ExpectedTodos{{"TODO: Something", {0, 4}, {0, 19}}};
     QTest::newRow("simple2")
         << "/// FIXME: Something\n"
         << ExpectedTodos{{"FIXME: Something", {0, 4}, {0, 20}}};
     QTest::newRow("mixed-content")
         << "/// FIXME: Something\n///Uninteresting content\n"
         << ExpectedTodos{{"FIXME: Something", {0, 4}, {0, 20}}};
     QTest::newRow("multi-line1")
         << "/**\n* foo\n*\n* FIXME: Something\n*/\n"
         << ExpectedTodos{{"FIXME: Something", {3, 2}, {3, 18}}};
     QTest::newRow("multi-line2")
         << "/// FIXME: Something\n///Uninteresting content\n"
         << ExpectedTodos{{"FIXME: Something", {0, 4}, {0, 20}}};
     QTest::newRow("multiple-todos-line2")
         << "/**\n* FIXME: one\n*foo bar\n* FIXME: two */\n"
         << ExpectedTodos{
             {"FIXME: one", {1, 2}, {1, 12}},
             {"FIXME: two", {3, 2}, {3, 12}}
         };
     QTest::newRow("todo-later-in-the-document")
         << "///foo\n\n///FIXME: bar\n"
         << ExpectedTodos{{"FIXME: bar", {2, 3}, {2, 13}}};
     QTest::newRow("non-ascii-todo")
         << "/* TODO: 例えば */"
         << ExpectedTodos{{"TODO: 例えば", {0, 3}, {0, 12}}};
 }
 
 void TestProblems::testProblemsForIncludedFiles()
 {
     TestFile header("#pragma once\n//TODO: header\n", "h");
     TestFile file("#include \"" + header.url().byteArray() + "\"\n//TODO: source\n", "cpp");
 
     file.parse(TopDUContext::Features(TopDUContext::AllDeclarationsContextsAndUses|TopDUContext::AST | TopDUContext::ForceUpdate));
     QVERIFY(file.waitForParsed(5000));
 
     {
         DUChainReadLocker lock;
         QVERIFY(file.topContext());
 
         auto context = DUChain::self()->chainForDocument(file.url());
         QVERIFY(context);
         QCOMPARE(context->problems().size(), 1);
         QCOMPARE(context->problems()[0]->description(), QStringLiteral("TODO: source"));
         QCOMPARE(context->problems()[0]->finalLocation().document, file.url());
 
         context = DUChain::self()->chainForDocument(header.url());
         QVERIFY(context);
         QCOMPARE(context->problems().size(), 1);
         QCOMPARE(context->problems()[0]->description(), QStringLiteral("TODO: header"));
         QCOMPARE(context->problems()[0]->finalLocation().document, header.url());
     }
 }
 
 using RangeList = QVector<KTextEditor::Range>;
 
 void TestProblems::testRanges_data()
 {
     QTest::addColumn<QByteArray>("code");
     QTest::addColumn<RangeList>("ranges");
 
     {
         // expected:
         // test.cpp:4:1: error: C++ requires a type specifier for all declarations
         // operator[](int){return string;}
         // ^
         //
         // test.cpp:4:24: error: 'string' does not refer to a value
         // operator[](int){return string;}
         //                        ^
         const QByteArray code = "struct string{};\nclass Test{\npublic:\noperator[](int){return string;}\n};";
         QTest::newRow("operator") << code << RangeList{{3, 0, 3, 8}, {3, 23, 3, 29}};
     }
     {
         const QByteArray code = "#include \"/some/file/that/does/not/exist.h\"\nint main() { return 0; }";
         QTest::newRow("badInclude") << code << RangeList{{0, 9, 0, 43}};
     }
     {
         const QByteArray code = "int main() const\n{ return 0; }";
         QTest::newRow("badConst") << code << RangeList{{0, 11, 0, 16}};
     }
 }
 
 void TestProblems::testRanges()
 {
     QFETCH(QByteArray, code);
     QFETCH(RangeList, ranges);
 
     const auto problems = parse(code);
     RangeList actualRanges;
     foreach (auto problem, problems) {
         actualRanges << problem->rangeInCurrentRevision();
     }
     qDebug() << actualRanges << ranges;
     QCOMPARE(actualRanges, ranges);
 }
 
 void TestProblems::testSeverity()
 {
     QFETCH(QByteArray, code);
     QFETCH(IProblem::Severity, severity);
 
     const auto problems = parse(code);
     QCOMPARE(problems.size(), 1);
     QCOMPARE(problems.at(0)->severity(), severity);
 }
 
 void TestProblems::testSeverity_data()
 {
     QTest::addColumn<QByteArray>("code");
     QTest::addColumn<IProblem::Severity>("severity");
 
     QTest::newRow("error") << QByteArray("class foo {}") << IProblem::Error;
     QTest::newRow("warning") << QByteArray("int main() { int foo = 1 / 0; return foo; }") << IProblem::Warning;
     QTest::newRow("hint-unused-variable") << QByteArray("int main() { int foo = 0; return 0; }") << IProblem::Hint;
     QTest::newRow("hint-unused-parameter") << QByteArray("int main(int argc, char**) { return 0; }") << IProblem::Hint;
 }