Supply c++11 flags and per-project info to c++ code model.

A manual squash/merge of the changes below, plus a couple of subsequent
code fixes.

59085aa5fbb99e2d786cd2c1a06c24a111ccb49f:
    Modify CppModel::ProjectInfo

    Adding per project node information, to pass on the correct
    defines/includes for each file, instead of aggregating them incorrectly.

    Also split up SOURCES and OBJECTIVE_SOURCES.

    Also ask the toolchain to convert the compilerflags to flags the
    codemodel understands, for now only gcc and only c++11.

    Also make the toolchain aware of the flags used to compile, so that it
    can emit the correct defines.

    Note: No header files are passed on.

74028802314cd4e75b41b46407433e07090a304d:
    GCC: Evaluate cxxflags when checking for predefined macros

ebaaa4957e4c02cc9637a998eddae1d0acd74f83:
    MSVC: Take cxxflags into account when checking for predefined macros

9bfce7e889bcf7bcc47bf880e3ea25945ca7d0d7:
    Compile fixes

Change-Id: I9de94ad038dfc5dc1987732e84b13fb4419c96f5
Reviewed-by: Erik Verbruggen <erik.verbruggen@nokia.com>

src/libs/cplusplus/ModelManagerInterface.cpp

@@ -32,6 +32,8 @@
 
 #include "ModelManagerInterface.h"
 
+#include <QtCore/QSet>
+
 using namespace CPlusPlus;
 
 static CppModelManagerInterface *g_instance = 0;
@@ -54,3 +56,44 @@ CppModelManagerInterface *CppModelManagerInterface::instance()
     return g_instance;
 }
 
+
+void CppModelManagerInterface::ProjectInfo::clearProjectParts()
+{
+    m_projectParts.clear();
+    m_includePaths.clear();
+    m_frameworkPaths.clear();
+    m_sourceFiles.clear();
+    m_defines.clear();
+}
+
+void CppModelManagerInterface::ProjectInfo::appendProjectPart(
+        const CppModelManagerInterface::ProjectPart::Ptr &part)
+{
+    if (!part)
+        return;
+
+    m_projectParts.append(part);
+
+    // update include paths
+    QSet<QString> incs = QSet<QString>::fromList(m_includePaths);
+    foreach (const QString &ins, part->includePaths)
+        incs.insert(ins);
+    m_includePaths = incs.toList();
+
+    // update framework paths
+    QSet<QString> frms = QSet<QString>::fromList(m_frameworkPaths);
+    foreach (const QString &frm, part->frameworkPaths)
+        frms.insert(frm);
+    m_frameworkPaths = frms.toList();
+
+    // update source files
+    QSet<QString> srcs = QSet<QString>::fromList(m_sourceFiles);
+    foreach (const QString &src, part->sourceFiles)
+        srcs.insert(src);
+    m_sourceFiles = srcs.toList();
+
+    // update defines
+    if (!m_defines.isEmpty())
+        m_defines.append('\n');
+    m_defines.append(part->defines);
+}

src/libs/cplusplus/ModelManagerInterface.h

@@ -35,6 +35,9 @@
 
 #include <cplusplus/CppDocument.h>
 #include <languageutils/fakemetaobject.h>
+#include <projectexplorer/project.h>
+#include <projectexplorer/toolchain.h>
+
 #include <QObject>
 #include <QHash>
 #include <QPointer>
@@ -66,33 +69,88 @@ class CPLUSPLUS_EXPORT CppModelManagerInterface : public QObject
     Q_OBJECT
 
 public:
+    enum Language { CXX, OBJC };
+
+    class CPLUSPLUS_EXPORT ProjectPart
+    {
+    public:
+        ProjectPart()
+            : qtVersion(UnknownQt)
+        {}
+
+    public: //attributes
+        QStringList sourceFiles;
+        QByteArray defines;
+        QStringList includePaths;
+        QStringList frameworkPaths;
+        QStringList precompiledHeaders;
+        Language language;
+        ProjectExplorer::ToolChain::CompilerFlags flags;
+        enum QtVersion {
+            UnknownQt = -1,
+            NoQt = 0,
+            Qt4 = 1,
+            Qt5 = 2
+        };
+        QtVersion qtVersion;
+
+        bool cpp0xEnabled() const
+        { return flags == ProjectExplorer::ToolChain::STD_CXX11; }
+
+        bool objcEnabled() const
+        { return language == CppModelManagerInterface::OBJC; }
+
+        typedef QSharedPointer<ProjectPart> Ptr;
+    };
+
     class ProjectInfo
     {
     public:
         ProjectInfo()
         { }
 
-        ProjectInfo(QPointer<ProjectExplorer::Project> project)
-            : project(project)
+        ProjectInfo(QWeakPointer<ProjectExplorer::Project> project)
+            : m_project(project)
         { }
 
         operator bool() const
-        { return ! project.isNull(); }
+        { return ! m_project.isNull(); }
 
         bool isValid() const
-        { return ! project.isNull(); }
+        { return ! m_project.isNull(); }
 
         bool isNull() const
-        { return project.isNull(); }
+        { return m_project.isNull(); }
 
-    public: // attributes
-        QPointer<ProjectExplorer::Project> project;
-        QString projectPath;
-        QByteArray defines;
-        QStringList sourceFiles;
-        QStringList includePaths;
-        QStringList frameworkPaths;
-        QStringList precompiledHeaders;
+        QWeakPointer<ProjectExplorer::Project> project() const
+        { return m_project; }
+
+        const QList<ProjectPart::Ptr> projectParts() const
+        { return m_projectParts; }
+
+        void clearProjectParts();
+        void appendProjectPart(const ProjectPart::Ptr &part);
+
+        const QStringList includePaths() const
+        { return m_includePaths; }
+
+        const QStringList frameworkPaths() const
+        { return m_frameworkPaths; }
+
+        const QStringList sourceFiles() const
+        { return m_sourceFiles; }
+
+        const QByteArray defines() const
+        { return m_defines; }
+
+    private: // attributes
+        QWeakPointer<ProjectExplorer::Project> m_project;
+        QList<ProjectPart::Ptr> m_projectParts;
+        // the attributes below are calculated from the project parts.
+        QStringList m_includePaths;
+        QStringList m_frameworkPaths;
+        QStringList m_sourceFiles;
+        QByteArray m_defines;
     };
 
     class WorkingCopy
@@ -110,6 +168,9 @@ public:
         QPair<QString, unsigned> get(const QString &fileName) const
         { return _elements.value(fileName); }
 
+        QHashIterator<QString, QPair<QString, unsigned> > iterator() const
+        { return QHashIterator<QString, QPair<QString, unsigned> >(_elements); }
+
     private:
         typedef QHash<QString, QPair<QString, unsigned> > Table;
         Table _elements;
@@ -135,6 +196,7 @@ public:
     virtual QList<ProjectInfo> projectInfos() const = 0;
     virtual ProjectInfo projectInfo(ProjectExplorer::Project *project) const = 0;
     virtual void updateProjectInfo(const ProjectInfo &pinfo) = 0;
+    virtual QList<ProjectPart::Ptr> projectPart(const QString &fileName) const = 0;
 
     virtual void addEditorSupport(CppTools::AbstractEditorSupport *editorSupport) = 0;
     virtual void removeEditorSupport(CppTools::AbstractEditorSupport *editorSupport) = 0;