CppTools: Use CompilerOptionsBuilder as an object

Makes the client code more readable.

Change-Id: Ie98ba93c758643039d3ebdc7550b1c4ac9473298
Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>
Reviewed-by: Christian Kandeler <christian.kandeler@theqtcompany.com>

src/plugins/clangcodemodel/clangutils.cpp

@@ -139,49 +139,53 @@ static bool maybeIncludeBorlandExtensions()
  */
 QStringList createClangOptions(const ProjectPart::Ptr &pPart, ProjectFile::Kind fileKind)
 {
-    QStringList result;
     if (pPart.isNull())
-        return result;
+        return QStringList();
+
+    CompilerOptionsBuilder optionsBuilder(pPart);
 
     if (verboseRunLog().isDebugEnabled())
-        result << QLatin1String("-v");
+        optionsBuilder.add(QLatin1String("-v"));
 
-    const bool objcExt = pPart->languageExtensions & ProjectPart::ObjectiveCExtensions;
+    optionsBuilder.addLanguageOption(fileKind);
-    result << CompilerOptionsBuilder::createLanguageOption(fileKind, objcExt);
+    optionsBuilder.addOptionsForLanguage(maybeIncludeBorlandExtensions());
-    result << CompilerOptionsBuilder::createOptionsForLanguage(
+    optionsBuilder.addToolchainAndProjectDefines();
-                  pPart->languageVersion,
-                  pPart->languageExtensions,
-                  maybeIncludeBorlandExtensions());
-    result << CompilerOptionsBuilder::createDefineOptions(pPart->toolchainDefines);
-    result << CompilerOptionsBuilder::createDefineOptions(pPart->projectDefines);
 
     static const QString resourceDir = getResourceDir();
     if (!resourceDir.isEmpty()) {
-        result << QLatin1String("-nostdlibinc");
+        optionsBuilder.add(QLatin1String("-nostdlibinc"));
-        result << (QLatin1String("-I") + resourceDir);
+        optionsBuilder.add(QLatin1String("-I") + resourceDir);
-        result << QLatin1String("-undef");
+        optionsBuilder.add(QLatin1String("-undef"));
     }
 
-    result << CompilerOptionsBuilder::createHeaderPathOptions(pPart->headerPaths, isBlacklisted);
+    optionsBuilder.addHeaderPathOptions(isBlacklisted);
 
     // Inject header file
     static const QString injectedHeader = ICore::instance()->resourcePath()
             + QLatin1String("/cplusplus/qt%1-qobjectdefs-injected.h");
-//    if (qtVersion == ProjectPart::Qt4)
-//        opts << QLatin1String("-include") << injectedHeader.arg(QLatin1Char('4'));
-    if (pPart->qtVersion == ProjectPart::Qt5)
-        result << QLatin1String("-include") << injectedHeader.arg(QLatin1Char('5'));
 
-    if (!pPart->projectConfigFile.isEmpty())
+//    if (pPart->qtVersion == ProjectPart::Qt4) {
-        result << QLatin1String("-include") << pPart->projectConfigFile;
+//        builder.addOption(QLatin1String("-include"));
+//        builder.addOption(injectedHeader.arg(QLatin1Char('4')));
+//    }
 
-    result << QLatin1String("-fmessage-length=0");
+    if (pPart->qtVersion == ProjectPart::Qt5) {
-    result << QLatin1String("-fdiagnostics-show-note-include-stack");
+        optionsBuilder.add(QLatin1String("-include"));
-    result << QLatin1String("-fmacro-backtrace-limit=0");
+        optionsBuilder.add(injectedHeader.arg(QLatin1Char('5')));
-    result << QLatin1String("-fretain-comments-from-system-headers");
+    }
+
+    if (!pPart->projectConfigFile.isEmpty()) {
+        optionsBuilder.add(QLatin1String("-include"));
+        optionsBuilder.add(pPart->projectConfigFile);
+    }
+
+    optionsBuilder.add(QLatin1String("-fmessage-length=0"));
+    optionsBuilder.add(QLatin1String("-fdiagnostics-show-note-include-stack"));
+    optionsBuilder.add(QLatin1String("-fmacro-backtrace-limit=0"));
+    optionsBuilder.add(QLatin1String("-fretain-comments-from-system-headers"));
     // TODO: -Xclang -ferror-limit -Xclang 0 ?
 
-    return result;
+    return optionsBuilder.options();
 }
 
 /// @return Option to speed up parsing with precompiled header

src/plugins/cpptools/cppprojects.cpp

@@ -501,9 +501,23 @@ void ProjectPartBuilder::createProjectPart(const QStringList &theSources,
 }
 
 
-QStringList CompilerOptionsBuilder::createHeaderPathOptions(
+CompilerOptionsBuilder::CompilerOptionsBuilder(const ProjectPart::Ptr &projectPart)
-        const ProjectPart::HeaderPaths &headerPaths,
+    : m_projectPart(projectPart)
-        IsBlackListed isBlackListed, const QString &toolchainType)
+{
+}
+
+QStringList CompilerOptionsBuilder::options() const
+{
+    return m_options;
+}
+
+void CompilerOptionsBuilder::add(const QString &option)
+{
+    m_options.append(option);
+}
+
+void CompilerOptionsBuilder::addHeaderPathOptions(IsBlackListed isBlackListed,
+                                                  const QString &toolchainType)
 {
     typedef ProjectPart::HeaderPath HeaderPath;
     const QString defaultPrefix
@@ -511,7 +525,7 @@ QStringList CompilerOptionsBuilder::createHeaderPathOptions(
 
     QStringList result;
 
-    foreach (const HeaderPath &headerPath , headerPaths) {
+    foreach (const HeaderPath &headerPath , m_projectPart->headerPaths) {
         if (headerPath.path.isEmpty())
             continue;
 
@@ -533,14 +547,12 @@ QStringList CompilerOptionsBuilder::createHeaderPathOptions(
         result.append(prefix + headerPath.path);
     }
 
-    return result;
+    m_options.append(result);
 }
 
-QStringList CompilerOptionsBuilder::createDefineOptions(const QByteArray &defines,
+void CompilerOptionsBuilder::addToolchainAndProjectDefines(const QString &toolchainType)
-                                                        bool toolchainDefines,
-                                                        const QString &toolchainType)
 {
-    QByteArray extendedDefines = defines;
+    QByteArray extendedDefines = m_projectPart->toolchainDefines + m_projectPart->projectDefines;
     QStringList result;
 
     // In gcc headers, lots of built-ins are referenced that clang does not understand.
@@ -559,17 +571,6 @@ QStringList CompilerOptionsBuilder::createDefineOptions(const QByteArray &define
         if (def.startsWith("#define __cplusplus"))
             continue;
 
-        // TODO: verify if we can pass compiler-defined macros when also passing -undef.
-        if (toolchainDefines) {
-            //### FIXME: the next 3 check shouldn't be needed: we probably don't want to get the compiler-defined defines in.
-            if (!def.startsWith("#define "))
-                continue;
-            if (def.startsWith("#define _"))
-                continue;
-            if (def.startsWith("#define OBJC_NEW_PROPERTIES"))
-                continue;
-        }
-
         // gcc 4.9 has:
         //    #define __has_include(STR) __has_include__(STR)
         //    #define __has_include_next(STR) __has_include_next__(STR)
@@ -590,7 +591,7 @@ QStringList CompilerOptionsBuilder::createDefineOptions(const QByteArray &define
             result.append(arg);
     }
 
-    return result;
+    m_options.append(result);
 }
 
 static QStringList createLanguageOptionGcc(ProjectFile::Kind fileKind, bool objcExt)
@@ -668,24 +669,26 @@ static QStringList createLanguageOptionMsvc(ProjectFile::Kind fileKind)
     return opts;
 }
 
-QStringList CompilerOptionsBuilder::createLanguageOption(ProjectFile::Kind fileKind, bool objcExt,
+void CompilerOptionsBuilder::addLanguageOption(ProjectFile::Kind fileKind,
-                                                         const QString &toolchainType)
+                                               const QString &toolchainType)
 {
-    return toolchainType == QLatin1String("msvc") ? createLanguageOptionMsvc(fileKind)
+    const bool objcExt = m_projectPart->languageExtensions & ProjectPart::ObjectiveCExtensions;
-                                                  : createLanguageOptionGcc(fileKind, objcExt);
+    const QStringList options = toolchainType == QLatin1String("msvc")
+            ? createLanguageOptionMsvc(fileKind)
+            : createLanguageOptionGcc(fileKind, objcExt);
+    m_options.append(options);
 }
 
-QStringList CompilerOptionsBuilder::createOptionsForLanguage(
+void CompilerOptionsBuilder::addOptionsForLanguage(bool checkForBorlandExtensions,
-    ProjectPart::LanguageVersion languageVersion,
+                                                   const QString &toolchainType)
-    ProjectPart::LanguageExtensions languageExtensions,
-    bool checkForBorlandExtensions,
-    const QString &toolchainType)
 {
     QStringList opts;
     if (toolchainType == QLatin1String("msvc"))
-        return opts;
+        return;
-    bool gnuExtensions = languageExtensions & ProjectPart::GnuExtensions;
+
-    switch (languageVersion) {
+    const ProjectPart::LanguageExtensions languageExtensions = m_projectPart->languageExtensions;
+    const bool gnuExtensions = languageExtensions & ProjectPart::GnuExtensions;
+    switch (m_projectPart->languageVersion) {
     case ProjectPart::C89:
         opts << (gnuExtensions ? QLatin1String("-std=gnu89") : QLatin1String("-std=c89"));
         break;
@@ -718,5 +721,5 @@ QStringList CompilerOptionsBuilder::createOptionsForLanguage(
     if (checkForBorlandExtensions && (languageExtensions & ProjectPart::BorlandExtensions))
         opts << QLatin1String("-fborland-extensions");
 
-    return opts;
+    m_options.append(opts);
 }

src/plugins/cpptools/cppprojects.h

@@ -214,21 +214,24 @@ private:
 class CPPTOOLS_EXPORT CompilerOptionsBuilder
 {
 public:
+    CompilerOptionsBuilder(const ProjectPart::Ptr &projectPart);
+
+    QStringList options() const;
+
+    void add(const QString &option);
+
     typedef std::function<bool (const QString &)> IsBlackListed;
-    static QStringList createHeaderPathOptions(const ProjectPart::HeaderPaths &headerPaths,
+    void addHeaderPathOptions(IsBlackListed isBlackListed = IsBlackListed(),
-                                               IsBlackListed isBlackListed = IsBlackListed(),
+                              const QString &toolchainType = QLatin1String("clang"));
-                                               const QString &toolchainType = QLatin1String("clang"));
+    void addToolchainAndProjectDefines(const QString &toolchainType = QLatin1String("clang"));
+    void addLanguageOption(ProjectFile::Kind fileKind,
+                           const QString &toolchainType = QLatin1String("clang"));
+    void addOptionsForLanguage(bool checkForBorlandExtensions = true,
+                               const QString &toolchainType = QLatin1String("clang"));
 
-    static QStringList createDefineOptions(const QByteArray &defines,
+private:
-                                           bool toolchainDefines = false,
+    ProjectPart::Ptr m_projectPart;
-                                           const QString &toolchainType = QLatin1String("clang"));
+    QStringList m_options;
-
-    static QStringList createLanguageOption(ProjectFile::Kind fileKind, bool objcExt,
-                                            const QString &toolchainType = QLatin1String("clang"));
-    static QStringList createOptionsForLanguage(ProjectPart::LanguageVersion languageVersion,
-                                                ProjectPart::LanguageExtensions languageExtensions,
-                                                bool checkForBorlandExtensions = true,
-                                                const QString &toolchainType = QLatin1String("clang"));
 };
 
 } // namespace CppTools