QmlJS: Add semantic errors to task window.

Task-number: QTCREATORBUG-4103
Reviewed-by: Leandro Melo

src/libs/qmljs/qmljslink.cpp

@@ -86,14 +86,16 @@ bool operator==(const ImportCacheKey &i1, const ImportCacheKey &i2)
 class QmlJS::LinkPrivate
 {
 public:
-    Document::Ptr doc;
     Snapshot snapshot;
     Interpreter::Context *context;
     QStringList importPaths;
 
     QHash<ImportCacheKey, Interpreter::ObjectValue *> importCache;
 
-    QList<DiagnosticMessage> diagnosticMessages;
+    Document::Ptr doc;
+    QList<DiagnosticMessage> *diagnosticMessages;
+
+    QHash<QString, QList<DiagnosticMessage> > *allDiagnosticMessages;
 };
 
 /*!
@@ -109,16 +111,42 @@ public:
     \l{Context} with \l{Link}.
 */
 
-Link::Link(Context *context, const Document::Ptr &doc, const Snapshot &snapshot,
-           const QStringList &importPaths)
+Link::Link(Context *context, const Snapshot &snapshot, const QStringList &importPaths,
+           QHash<QString, QList<DiagnosticMessage> > *messages)
     : d_ptr(new LinkPrivate)
 {
     Q_D(Link);
     d->context = context;
-    d->doc = doc;
     d->snapshot = snapshot;
     d->importPaths = importPaths;
 
+    d->diagnosticMessages = 0;
+    d->allDiagnosticMessages = messages;
+
+    // populate engine with types from C++
+    ModelManagerInterface *modelManager = ModelManagerInterface::instance();
+    if (modelManager) {
+        foreach (const QList<FakeMetaObject::ConstPtr> &cppTypes, modelManager->cppQmlTypes()) {
+            engine()->cppQmlTypes().load(engine(), cppTypes);
+        }
+    }
+
+    linkImports();
+}
+
+Link::Link(Context *context, const Snapshot &snapshot, const QStringList &importPaths,
+           const Document::Ptr &doc, QList<DiagnosticMessage> *messages)
+    : d_ptr(new LinkPrivate)
+{
+    Q_D(Link);
+    d->context = context;
+    d->snapshot = snapshot;
+    d->importPaths = importPaths;
+
+    d->doc = doc;
+    d->diagnosticMessages = messages;
+    d->allDiagnosticMessages = 0;
+
     // populate engine with types from C++
     ModelManagerInterface *modelManager = ModelManagerInterface::instance();
     if (modelManager) {
@@ -140,20 +168,16 @@ Interpreter::Engine *Link::engine()
     return d->context->engine();
 }
 
-QList<DiagnosticMessage> Link::diagnosticMessages() const
-{
-    Q_D(const Link);
-    return d->diagnosticMessages;
-}
-
 void Link::linkImports()
 {
     Q_D(Link);
 
+    if (d->doc) {
         // do it on d->doc first, to make sure import errors are shown
         TypeEnvironment *typeEnv = new TypeEnvironment(engine());
         populateImportedTypes(typeEnv, d->doc);
         d->context->setTypeEnvironment(d->doc.data(), typeEnv);
+    }
 
     foreach (Document::Ptr doc, d->snapshot) {
         if (doc == d->doc)
@@ -364,18 +388,22 @@ UiQualifiedId *Link::qualifiedTypeNameId(Node *node)
 
 void Link::error(const Document::Ptr &doc, const AST::SourceLocation &loc, const QString &message)
 {
-    Q_D(Link);
-
-    if (doc->fileName() == d->doc->fileName())
-        d->diagnosticMessages.append(DiagnosticMessage(DiagnosticMessage::Error, loc, message));
+    appendDiagnostic(doc, DiagnosticMessage(DiagnosticMessage::Error, loc, message));
 }
 
 void Link::warning(const Document::Ptr &doc, const AST::SourceLocation &loc, const QString &message)
+{
+    appendDiagnostic(doc, DiagnosticMessage(DiagnosticMessage::Warning, loc, message));
+}
+
+void Link::appendDiagnostic(const Document::Ptr &doc, const DiagnosticMessage &message)
 {
     Q_D(Link);
 
-    if (doc->fileName() == d->doc->fileName())
-        d->diagnosticMessages.append(DiagnosticMessage(DiagnosticMessage::Warning, loc, message));
+    if (d->diagnosticMessages && doc->fileName() == d->doc->fileName())
+        d->diagnosticMessages->append(message);
+    if (d->allDiagnosticMessages)
+        (*d->allDiagnosticMessages)[doc->fileName()].append(message);
 }
 
 void Link::loadQmldirComponents(Interpreter::ObjectValue *import, ComponentVersion version,

src/libs/qmljs/qmljslink.h

@@ -54,12 +54,16 @@ class QMLJS_EXPORT Link
     Q_DECLARE_TR_FUNCTIONS(QmlJS::Link)
 
 public:
-    // Link all documents in snapshot
-    Link(Interpreter::Context *context, const Document::Ptr &doc, const Snapshot &snapshot,
-         const QStringList &importPaths);
-    ~Link();
+    // Link all documents in snapshot, collecting all diagnostic messages
+    Link(Interpreter::Context *context, const Snapshot &snapshot,
+         const QStringList &importPaths, QHash<QString, QList<DiagnosticMessage> > *messages = 0);
 
-    QList<DiagnosticMessage> diagnosticMessages() const;
+    // Link all documents in snapshot, appending the diagnostic messages
+    // for 'doc' in 'messages'
+    Link(Interpreter::Context *context, const Snapshot &snapshot,
+         const QStringList &importPaths, const Document::Ptr &doc, QList<DiagnosticMessage> *messages);
+
+    ~Link();
 
 private:
     Interpreter::Engine *engine();
@@ -87,6 +91,7 @@ private:
 
     void error(const Document::Ptr &doc, const AST::SourceLocation &loc, const QString &message);
     void warning(const Document::Ptr &doc, const AST::SourceLocation &loc, const QString &message);
+    void appendDiagnostic(const Document::Ptr &doc, const DiagnosticMessage &message);
 
 private:
     QScopedPointer<LinkPrivate> d_ptr;

src/libs/qmljs/qmljslookupcontext.cpp

@@ -47,7 +47,7 @@ public:
           snapshot(snapshot)
     {
         // since we keep the document and snapshot around, we don't need to keep the Link instance
-        Link link(&context, doc, snapshot, ModelManagerInterface::instance()->importPaths());
+        Link link(&context, snapshot, ModelManagerInterface::instance()->importPaths());
 
         ScopeBuilder scopeBuilder(&context, doc, snapshot);
         scopeBuilder.push(path);

src/libs/qmljs/qmljsmodelmanagerinterface.h

@@ -142,6 +142,7 @@ signals:
     void documentChangedOnDisk(QmlJS::Document::Ptr doc);
     void aboutToRemoveFiles(const QStringList &files);
     void libraryInfoUpdated(const QString &path, const QmlJS::LibraryInfo &info);
+    void projectInfoUpdated(const ProjectInfo &pinfo);
 };
 
 } // namespace QmlJS

src/plugins/qmldesigner/designercore/model/texttomodelmerger.cpp

@@ -283,7 +283,7 @@ public:
         : m_snapshot(snapshot)
         , m_doc(doc)
         , m_context(new Interpreter::Context)
-        , m_link(m_context, doc, snapshot, importPaths)
+        , m_link(m_context, snapshot, importPaths, doc, &m_diagnosticLinkMessages)
         , m_lookupContext(LookupContext::create(doc, snapshot, *m_context, QList<AST::Node*>()))
         , m_scopeBuilder(m_context, doc, snapshot)
     {
@@ -542,13 +542,14 @@ public:
     { return m_lookupContext; }
 
     QList<DiagnosticMessage> diagnosticLinkMessages() const
-    { return m_link.diagnosticMessages(); }
+    { return m_diagnosticLinkMessages; }
 
 private:
     Snapshot m_snapshot;
     Document::Ptr m_doc;
     Interpreter::Context *m_context;
     Link m_link;
+    QList<DiagnosticMessage> m_diagnosticLinkMessages;
     LookupContext::Ptr m_lookupContext;
     ScopeBuilder m_scopeBuilder;
 };

src/plugins/qmljseditor/qmljseditorplugin.cpp

@@ -237,7 +237,13 @@ bool QmlJSEditorPlugin::initialize(const QStringList & /*arguments*/, QString *e
     addAutoReleasedObject(m_qmlTaskManager);
 
     connect(m_modelManager, SIGNAL(documentChangedOnDisk(QmlJS::Document::Ptr)),
-            m_qmlTaskManager, SLOT(documentChangedOnDisk(QmlJS::Document::Ptr)));
+            m_qmlTaskManager, SLOT(updateMessages()));
+    // recompute messages when information about libraries changes
+    connect(m_modelManager, SIGNAL(libraryInfoUpdated(QString,QmlJS::LibraryInfo)),
+            m_qmlTaskManager, SLOT(updateMessages()));
+    // recompute messages when project data changes (files added or removed)
+    connect(m_modelManager, SIGNAL(projectInfoUpdated(ProjectInfo)),
+            m_qmlTaskManager, SLOT(updateMessages()));
     connect(m_modelManager, SIGNAL(aboutToRemoveFiles(QStringList)),
             m_qmlTaskManager, SLOT(documentsRemoved(QStringList)));
 

src/plugins/qmljseditor/qmljsfindreferences.cpp

@@ -626,7 +626,7 @@ static void find_helper(QFutureInterface<FindReferences::Usage> &future,
     if (!doc)
         return;
 
-    Link link(&context, doc, snapshot, ModelManagerInterface::instance()->importPaths());
+    Link link(&context, snapshot, ModelManagerInterface::instance()->importPaths());
     ScopeBuilder builder(&context, doc, snapshot);
     ScopeAstPath astPath(doc);
     builder.push(astPath(offset));

src/plugins/qmljseditor/qmljssemantichighlighter.cpp

@@ -133,13 +133,9 @@ SemanticInfo SemanticHighlighter::semanticInfo(const SemanticHighlighterSource &
     semanticInfo.document = doc;
 
     QmlJS::Interpreter::Context *ctx = new QmlJS::Interpreter::Context;
-    QmlJS::Link link(ctx, doc, snapshot, QmlJS::ModelManagerInterface::instance()->importPaths());
+    QmlJS::Link link(ctx, snapshot, QmlJS::ModelManagerInterface::instance()->importPaths(), doc, &semanticInfo.semanticMessages);
     semanticInfo.m_context = QSharedPointer<const QmlJS::Interpreter::Context>(ctx);
-    semanticInfo.semanticMessages = link.diagnosticMessages();
 
-    QStringList importPaths;
-    if (m_modelManager)
-        importPaths = m_modelManager->importPaths();
     QmlJS::Check checker(doc, snapshot, ctx);
     semanticInfo.semanticMessages.append(checker());
 

src/plugins/qmljseditor/qmltaskmanager.cpp

@@ -33,11 +33,21 @@
 #include "qmltaskmanager.h"
 #include "qmljseditorconstants.h"
 
+#include <coreplugin/ifile.h>
 #include <extensionsystem/pluginmanager.h>
 #include <projectexplorer/taskhub.h>
 #include <qmljs/qmljsmodelmanagerinterface.h>
+#include <qmljs/qmljsinterpreter.h>
+#include <qmljs/qmljslink.h>
+#include <qmljs/qmljscheck.h>
+#include <qmljseditor/qmljseditor.h>
+#include <qmljseditor/qmljseditoreditable.h>
 
 #include <QtCore/QDebug>
+#include <QtCore/QtConcurrentRun>
+#include <qtconcurrent/runextensions.h>
+
+using namespace QmlJS;
 
 namespace QmlJSEditor {
 namespace Internal {
@@ -47,35 +57,103 @@ QmlTaskManager::QmlTaskManager(QObject *parent) :
         m_taskHub(0)
 {
     m_taskHub = ExtensionSystem::PluginManager::instance()->getObject<ProjectExplorer::TaskHub>();
+    // displaying results incrementally leads to flickering
+//    connect(&m_messageCollector, SIGNAL(resultsReadyAt(int,int)),
+//            SLOT(displayResults(int,int)));
+    connect(&m_messageCollector, SIGNAL(finished()),
+            SLOT(displayAllResults()));
+
+    m_updateDelay.setInterval(100);
+    m_updateDelay.setSingleShot(true);
+    connect(&m_updateDelay, SIGNAL(timeout()),
+            SLOT(updateMessagesNow()));
 }
 
-void QmlTaskManager::documentChangedOnDisk(QmlJS::Document::Ptr doc)
+void QmlTaskManager::collectMessages(QFutureInterface<FileErrorMessages> &future,
+    Snapshot snapshot, QStringList files, QStringList importPaths)
 {
-    const QString fileName = doc->fileName();
-    removeTasksForFile(fileName);
+    Interpreter::Context ctx;
+    QHash<QString, QList<DiagnosticMessage> > linkMessages;
+    Link link(&ctx, snapshot, importPaths, &linkMessages);
 
-    foreach (const QmlJS::DiagnosticMessage &msg, doc->diagnosticMessages()) {
-        ProjectExplorer::Task::TaskType type
-                = msg.isError() ? ProjectExplorer::Task::Error
-                                : ProjectExplorer::Task::Warning;
+    foreach (const QString &fileName, files) {
+        Document::Ptr document = snapshot.document(fileName);
+        if (!document)
+            continue;
 
-        ProjectExplorer::Task task(type, msg.message, fileName, msg.loc.startLine,
-                                   Constants::TASK_CATEGORY_QML);
-        insertTask(fileName, task);
+        FileErrorMessages result;
+        result.fileName = fileName;
+        result.messages = document->diagnosticMessages();
+        result.messages += linkMessages.value(fileName);
+
+        Check checker(document, snapshot, &ctx);
+        result.messages.append(checker());
+
+        future.reportResult(result);
+        if (future.isCanceled())
+            break;
     }
 }
 
+void QmlTaskManager::updateMessages()
+{
+    m_updateDelay.start();
+}
+
+void QmlTaskManager::updateMessagesNow()
+{
+    // abort any update that's going on already
+    m_messageCollector.cancel();
+    removeAllTasks();
+
+    // collect all the source files in open projects
+    ModelManagerInterface *modelManager = ModelManagerInterface::instance();
+    QStringList sourceFiles;
+    foreach (const ModelManagerInterface::ProjectInfo &info, modelManager->projectInfos()) {
+        sourceFiles += info.sourceFiles;
+    }
+
+    // process them
+    QFuture<FileErrorMessages> future =
+            QtConcurrent::run<FileErrorMessages>(
+                &collectMessages, modelManager->snapshot(), sourceFiles,
+                modelManager->importPaths());
+    m_messageCollector.setFuture(future);
+}
+
 void QmlTaskManager::documentsRemoved(const QStringList path)
 {
     foreach (const QString &item, path)
         removeTasksForFile(item);
 }
 
-void QmlTaskManager::insertTask(const QString &fileName, const ProjectExplorer::Task &task)
+void QmlTaskManager::displayResults(int begin, int end)
 {
-    QList<ProjectExplorer::Task> tasks = m_docsWithTasks.value(fileName);
+    for (int i = begin; i < end; ++i) {
+        FileErrorMessages result = m_messageCollector.resultAt(i);
+        foreach (const DiagnosticMessage &msg, result.messages) {
+            ProjectExplorer::Task::TaskType type
+                    = msg.isError() ? ProjectExplorer::Task::Error
+                                    : ProjectExplorer::Task::Warning;
+
+            ProjectExplorer::Task task(type, msg.message, result.fileName, msg.loc.startLine,
+                                       Constants::TASK_CATEGORY_QML);
+
+            insertTask(task);
+        }
+    }
+}
+
+void QmlTaskManager::displayAllResults()
+{
+    displayResults(0, m_messageCollector.future().resultCount());
+}
+
+void QmlTaskManager::insertTask(const ProjectExplorer::Task &task)
+{
+    QList<ProjectExplorer::Task> tasks = m_docsWithTasks.value(task.file);
     tasks.append(task);
-    m_docsWithTasks.insert(fileName, tasks);
+    m_docsWithTasks.insert(task.file, tasks);
     m_taskHub->addTask(task);
 }
 
@@ -89,5 +167,16 @@ void QmlTaskManager::removeTasksForFile(const QString &fileName)
     }
 }
 
+void QmlTaskManager::removeAllTasks()
+{
+    QMapIterator<QString, QList<ProjectExplorer::Task> > it(m_docsWithTasks);
+    while (it.hasNext()) {
+        it.next();
+        foreach (const ProjectExplorer::Task &task, it.value())
+            m_taskHub->removeTask(task);
+    }
+    m_docsWithTasks.clear();
+}
+
 } // Internal
 } // QmlProjectManager

src/plugins/qmljseditor/qmltaskmanager.h

@@ -40,6 +40,12 @@
 #include <QtCore/QList>
 #include <QtCore/QMap>
 #include <QtCore/QString>
+#include <QtCore/QFutureWatcher>
+#include <QtCore/QTimer>
+
+namespace QmlJSEditor {
+class QmlJSTextEditorWidget;
+}
 
 namespace ProjectExplorer {
 class TaskHub;
@@ -57,16 +63,34 @@ public:
     void extensionsInitialized();
 
 public slots:
-    void documentChangedOnDisk(QmlJS::Document::Ptr doc);
+    void updateMessages();
     void documentsRemoved(const QStringList path);
 
+private slots:
+    void displayResults(int begin, int end);
+    void displayAllResults();
+    void updateMessagesNow();
+
 private:
-    void insertTask(const QString &fileName, const ProjectExplorer::Task &task);
+    void insertTask(const ProjectExplorer::Task &task);
     void removeTasksForFile(const QString &fileName);
+    void removeAllTasks();
+
+private:
+    class FileErrorMessages
+    {
+    public:
+        QString fileName;
+        QList<QmlJS::DiagnosticMessage> messages;
+    };
+    static void collectMessages(QFutureInterface<FileErrorMessages> &future,
+                                QmlJS::Snapshot snapshot, QStringList files, QStringList importPaths);
 
 private:
     ProjectExplorer::TaskHub *m_taskHub;
     QMap<QString, QList<ProjectExplorer::Task> > m_docsWithTasks;
+    QFutureWatcher<FileErrorMessages> m_messageCollector;
+    QTimer m_updateDelay;
 };
 
 } // Internal

src/plugins/qmljstools/qmljsmodelmanager.cpp

@@ -265,6 +265,8 @@ void ModelManager::updateProjectInfo(const ProjectInfo &pinfo)
             newFiles += file;
     }
     updateSourceFiles(newFiles, false);
+
+    emit projectInfoUpdated(pinfo);
 }
 
 void ModelManager::emitDocumentChangedOnDisk(Document::Ptr doc)