QmlJSEditor: Move semantic info updating to document

Change-Id: I804dbd887af1786e7554ec79f94fc8e59db1de5b
Reviewed-by: Fawzi Mohamed <fawzi.mohamed@digia.com>

src/libs/qmljs/qmljscontext.cpp

@@ -49,9 +49,9 @@ using namespace QmlJS::AST;
 
     Information about the imports of a Document can be accessed with imports().
 
-    When dealing with a QmlJSEditor::QmlJSTextEditorWidget it is unnecessary to
+    When dealing with a QmlJSEditor::QmlJSEditorDocument it is unnecessary to
     construct a new Context manually. Instead use
-    QmlJSTextEditorWidget::semanticInfo()::context.
+    QmlJSEditorDocument::semanticInfo()::context.
 */
 
 ContextPtr Context::create(const QmlJS::Snapshot &snapshot, ValueOwner *valueOwner,

src/libs/qmljs/qmljslink.cpp

@@ -130,7 +130,7 @@ public:
     Initializes a context by resolving imports. This is an expensive operation.
 
     Instead of making a fresh context, consider reusing the one maintained in the
-    \l{QmlJSEditor::SemanticInfo} of a \l{QmlJSEditor::QmlJSTextEditorWidget}.
+    \l{QmlJSEditor::SemanticInfo} of a \l{QmlJSEditor::QmlJSEditorDocument}.
 */
 
 Link::Link(const Snapshot &snapshot, const ViewerContext &vContext, const LibraryInfo &builtins)

src/libs/qmljs/qmljsscopechain.cpp

@@ -50,9 +50,9 @@ using namespace QmlJS;
     It is an error to use the same ScopeChain from multiple threads; use a copy.
     Copying is cheap. Initial construction is currently expensive.
 
-    When a QmlJSEditor::QmlJSTextEditorWidget is available, there's no need to
+    When a QmlJSEditor::QmlJSEditorDocument is available, there's no need to
     construct a new ScopeChain. Instead use
-    QmlJSTextEditorWidget::semanticInfo()::scopeChain().
+    QmlJSEditorDocument::semanticInfo()::scopeChain().
 */
 
 QmlComponentChain::QmlComponentChain(const Document::Ptr &document)

src/plugins/qmljseditor/qmljseditor.h

@@ -69,6 +69,7 @@ class QmlJSEditor;
 class FindReferences;
 
 namespace Internal {
+class QmlJSEditorDocument;
 class QmlOutlineModel;
 class SemanticInfoUpdater;
 struct SemanticInfoUpdaterSource;
@@ -96,9 +97,6 @@ class QMLJSEDITOR_EXPORT QmlJSTextEditorWidget : public TextEditor::BaseTextEdit
 {
     Q_OBJECT
 
-    // used e.g. in qmljsprofiler
-    Q_PROPERTY(QmlJSTools::SemanticInfo semanticInfo READ semanticInfo)
-
 public:
     QmlJSTextEditorWidget(QWidget *parent = 0);
     QmlJSTextEditorWidget(QmlJSTextEditorWidget *other);
@@ -106,9 +104,11 @@ public:
 
     virtual void unCommentSelection();
 
+    // redirecting to document
     QmlJSTools::SemanticInfo semanticInfo() const;
     bool isSemanticInfoOutdated() const;
     int editorRevision() const;
+
     QVector<QTextLayout::FormatRange> diagnosticRanges() const;
 
     Internal::QmlOutlineModel *outlineModel() const;
@@ -119,8 +119,6 @@ public:
     TextEditor::IAssistInterface *createAssistInterface(TextEditor::AssistKind assistKind,
                                                         TextEditor::AssistReason reason) const;
 public slots:
-    void updateSemanticInfo();
-    void updateSemanticInfoNow();
     void findUsages();
     void renameUsages();
     void showContextPane();
@@ -132,7 +130,6 @@ signals:
     void semanticInfoUpdated();
 
 private slots:
-    void onDocumentUpdated(QmlJS::Document::Ptr doc);
     void modificationChanged(bool);
 
     void jumpToOutlineElement(int index);
@@ -144,11 +141,12 @@ private slots:
     void updateUses();
     void updateUsesNow();
 
-    void acceptNewSemanticInfo(const QmlJSTools::SemanticInfo &semanticInfo);
+    void semanticInfoUpdated(const QmlJSTools::SemanticInfo &semanticInfo);
     void onCursorPositionChanged();
     void onRefactorMarkerClicked(const TextEditor::RefactorMarker &marker);
 
     void performQuickFix(int index);
+    void updateCodeWarnings(QmlJS::Document::Ptr doc);
 
 protected:
     void contextMenuEvent(QContextMenuEvent *e);
@@ -175,8 +173,8 @@ private:
     QModelIndex indexForPosition(unsigned cursorPosition, const QModelIndex &rootIndex = QModelIndex()) const;
     bool hideContextPane();
 
+    Internal::QmlJSEditorDocument *m_qmlJsEditorDocument;
     QTimer *m_updateUsesTimer;
-    QTimer *m_updateSemanticInfoTimer;
     QTimer *m_updateOutlineTimer;
     QTimer *m_updateOutlineIndexTimer;
     QTimer *m_cursorPositionTimer;
@@ -185,10 +183,6 @@ private:
     QModelIndex m_outlineModelIndex;
     QmlJS::ModelManagerInterface *m_modelManager;
 
-    Internal::SemanticInfoUpdater *m_semanticInfoUpdater;
-    QmlJSTools::SemanticInfo m_semanticInfo;
-    int m_futureSemanticInfoRevision;
-
     QList<TextEditor::QuickFixOperation::Ptr> m_quickFixes;
     QVector<QTextLayout::FormatRange> m_diagnosticRanges;
 

src/plugins/qmljseditor/qmljseditordocument.cpp

@@ -31,13 +31,16 @@
 
 #include "qmljseditordocument_p.h"
 #include "qmljshighlighter.h"
+#include "qmljssemanticinfoupdater.h"
 
 #include <qmljstools/qmljsindenter.h>
 #include <qmljstools/qmljsmodelmanager.h>
 #include <qmljstools/qmljsqtstylecodeformatter.h>
 
 using namespace QmlJSEditor;
-using namespace QmlJSEditor::Internal;
+using namespace QmlJS;
+using namespace QmlJS::AST;
+using namespace QmlJSTools;
 
 namespace {
 
@@ -45,30 +48,448 @@ enum {
     UPDATE_DOCUMENT_DEFAULT_INTERVAL = 100
 };
 
+class FindIdDeclarations: protected Visitor
+{
+public:
+    typedef QHash<QString, QList<AST::SourceLocation> > Result;
+
+    Result operator()(Document::Ptr doc)
+    {
+        _ids.clear();
+        _maybeIds.clear();
+        if (doc && doc->qmlProgram())
+            doc->qmlProgram()->accept(this);
+        return _ids;
+    }
+
+protected:
+    QString asString(AST::UiQualifiedId *id)
+    {
+        QString text;
+        for (; id; id = id->next) {
+            if (!id->name.isEmpty())
+                text += id->name;
+            else
+                text += QLatin1Char('?');
+
+            if (id->next)
+                text += QLatin1Char('.');
+        }
+
+        return text;
+    }
+
+    void accept(AST::Node *node)
+    { AST::Node::acceptChild(node, this); }
+
+    using Visitor::visit;
+    using Visitor::endVisit;
+
+    virtual bool visit(AST::UiScriptBinding *node)
+    {
+        if (asString(node->qualifiedId) == QLatin1String("id")) {
+            if (AST::ExpressionStatement *stmt = AST::cast<AST::ExpressionStatement*>(node->statement)) {
+                if (AST::IdentifierExpression *idExpr = AST::cast<AST::IdentifierExpression *>(stmt->expression)) {
+                    if (!idExpr->name.isEmpty()) {
+                        const QString &id = idExpr->name.toString();
+                        QList<AST::SourceLocation> *locs = &_ids[id];
+                        locs->append(idExpr->firstSourceLocation());
+                        locs->append(_maybeIds.value(id));
+                        _maybeIds.remove(id);
+                        return false;
+                    }
+                }
+            }
+        }
+
+        accept(node->statement);
+
+        return false;
+    }
+
+    virtual bool visit(AST::IdentifierExpression *node)
+    {
+        if (!node->name.isEmpty()) {
+            const QString &name = node->name.toString();
+
+            if (_ids.contains(name))
+                _ids[name].append(node->identifierToken);
+            else
+                _maybeIds[name].append(node->identifierToken);
+        }
+        return false;
+    }
+
+private:
+    Result _ids;
+    Result _maybeIds;
+};
+
+class FindDeclarations: protected Visitor
+{
+    QList<Declaration> _declarations;
+    int _depth;
+
+public:
+    QList<Declaration> operator()(AST::Node *node)
+    {
+        _depth = -1;
+        _declarations.clear();
+        accept(node);
+        return _declarations;
+    }
+
+protected:
+    using Visitor::visit;
+    using Visitor::endVisit;
+
+    QString asString(AST::UiQualifiedId *id)
+    {
+        QString text;
+        for (; id; id = id->next) {
+            if (!id->name.isEmpty())
+                text += id->name;
+            else
+                text += QLatin1Char('?');
+
+            if (id->next)
+                text += QLatin1Char('.');
+        }
+
+        return text;
+    }
+
+    void accept(AST::Node *node)
+    { AST::Node::acceptChild(node, this); }
+
+    void init(Declaration *decl, AST::UiObjectMember *member)
+    {
+        const SourceLocation first = member->firstSourceLocation();
+        const SourceLocation last = member->lastSourceLocation();
+        decl->startLine = first.startLine;
+        decl->startColumn = first.startColumn;
+        decl->endLine = last.startLine;
+        decl->endColumn = last.startColumn + last.length;
+    }
+
+    void init(Declaration *decl, AST::ExpressionNode *expressionNode)
+    {
+        const SourceLocation first = expressionNode->firstSourceLocation();
+        const SourceLocation last = expressionNode->lastSourceLocation();
+        decl->startLine = first.startLine;
+        decl->startColumn = first.startColumn;
+        decl->endLine = last.startLine;
+        decl->endColumn = last.startColumn + last.length;
+    }
+
+    virtual bool visit(AST::UiObjectDefinition *node)
+    {
+        ++_depth;
+
+        Declaration decl;
+        init(&decl, node);
+
+        decl.text.fill(QLatin1Char(' '), _depth);
+        if (node->qualifiedTypeNameId)
+            decl.text.append(asString(node->qualifiedTypeNameId));
+        else
+            decl.text.append(QLatin1Char('?'));
+
+        _declarations.append(decl);
+
+        return true; // search for more bindings
+    }
+
+    virtual void endVisit(AST::UiObjectDefinition *)
+    {
+        --_depth;
+    }
+
+    virtual bool visit(AST::UiObjectBinding *node)
+    {
+        ++_depth;
+
+        Declaration decl;
+        init(&decl, node);
+
+        decl.text.fill(QLatin1Char(' '), _depth);
+
+        decl.text.append(asString(node->qualifiedId));
+        decl.text.append(QLatin1String(": "));
+
+        if (node->qualifiedTypeNameId)
+            decl.text.append(asString(node->qualifiedTypeNameId));
+        else
+            decl.text.append(QLatin1Char('?'));
+
+        _declarations.append(decl);
+
+        return true; // search for more bindings
+    }
+
+    virtual void endVisit(AST::UiObjectBinding *)
+    {
+        --_depth;
+    }
+
+    virtual bool visit(AST::UiScriptBinding *)
+    {
+        ++_depth;
+
+#if 0 // ### ignore script bindings for now.
+        Declaration decl;
+        init(&decl, node);
+
+        decl.text.fill(QLatin1Char(' '), _depth);
+        decl.text.append(asString(node->qualifiedId));
+
+        _declarations.append(decl);
+#endif
+
+        return false; // more more bindings in this subtree.
+    }
+
+    virtual void endVisit(AST::UiScriptBinding *)
+    {
+        --_depth;
+    }
+
+    virtual bool visit(AST::FunctionExpression *)
+    {
+        return false;
+    }
+
+    virtual bool visit(AST::FunctionDeclaration *ast)
+    {
+        if (ast->name.isEmpty())
+            return false;
+
+        Declaration decl;
+        init(&decl, ast);
+
+        decl.text.fill(QLatin1Char(' '), _depth);
+        decl.text += ast->name;
+
+        decl.text += QLatin1Char('(');
+        for (FormalParameterList *it = ast->formals; it; it = it->next) {
+            if (!it->name.isEmpty())
+                decl.text += it->name;
+
+            if (it->next)
+                decl.text += QLatin1String(", ");
+        }
+
+        decl.text += QLatin1Char(')');
+
+        _declarations.append(decl);
+
+        return false;
+    }
+
+    virtual bool visit(AST::VariableDeclaration *ast)
+    {
+        if (ast->name.isEmpty())
+            return false;
+
+        Declaration decl;
+        decl.text.fill(QLatin1Char(' '), _depth);
+        decl.text += ast->name;
+
+        const SourceLocation first = ast->identifierToken;
+        decl.startLine = first.startLine;
+        decl.startColumn = first.startColumn;
+        decl.endLine = first.startLine;
+        decl.endColumn = first.startColumn + first.length;
+
+        _declarations.append(decl);
+
+        return false;
+    }
+};
+
+class CreateRanges: protected AST::Visitor
+{
+    QTextDocument *_textDocument;
+    QList<Range> _ranges;
+
+public:
+    QList<Range> operator()(QTextDocument *textDocument, Document::Ptr doc)
+    {
+        _textDocument = textDocument;
+        _ranges.clear();
+        if (doc && doc->ast() != 0)
+            doc->ast()->accept(this);
+        return _ranges;
+    }
+
+protected:
+    using AST::Visitor::visit;
+
+    virtual bool visit(AST::UiObjectBinding *ast)
+    {
+        if (ast->initializer && ast->initializer->lbraceToken.length)
+            _ranges.append(createRange(ast, ast->initializer));
+        return true;
+    }
+
+    virtual bool visit(AST::UiObjectDefinition *ast)
+    {
+        if (ast->initializer && ast->initializer->lbraceToken.length)
+            _ranges.append(createRange(ast, ast->initializer));
+        return true;
+    }
+
+    virtual bool visit(AST::FunctionExpression *ast)
+    {
+        _ranges.append(createRange(ast));
+        return true;
+    }
+
+    virtual bool visit(AST::FunctionDeclaration *ast)
+    {
+        _ranges.append(createRange(ast));
+        return true;
+    }
+
+    virtual bool visit(AST::UiScriptBinding *ast)
+    {
+        if (AST::Block *block = AST::cast<AST::Block *>(ast->statement))
+            _ranges.append(createRange(ast, block));
+        return true;
+    }
+
+    Range createRange(AST::UiObjectMember *member, AST::UiObjectInitializer *ast)
+    {
+        return createRange(member, member->firstSourceLocation(), ast->rbraceToken);
+    }
+
+    Range createRange(AST::FunctionExpression *ast)
+    {
+        return createRange(ast, ast->lbraceToken, ast->rbraceToken);
+    }
+
+    Range createRange(AST::UiScriptBinding *ast, AST::Block *block)
+    {
+        return createRange(ast, block->lbraceToken, block->rbraceToken);
+    }
+
+    Range createRange(AST::Node *ast, AST::SourceLocation start, AST::SourceLocation end)
+    {
+        Range range;
+
+        range.ast = ast;
+
+        range.begin = QTextCursor(_textDocument);
+        range.begin.setPosition(start.begin());
+
+        range.end = QTextCursor(_textDocument);
+        range.end.setPosition(end.end());
+
+        return range;
+    }
+};
+
 }
 
+namespace QmlJSEditor {
+namespace Internal {
+
 QmlJSEditorDocumentPrivate::QmlJSEditorDocumentPrivate(QmlJSEditorDocument *parent)
-    : m_q(parent)
+    : m_q(parent),
+      m_semanticInfoDocRevision(-1)
 {
+    ModelManagerInterface *modelManager = ModelManagerInterface::instance();
+
+    // code model
     m_updateDocumentTimer = new QTimer(this);
     m_updateDocumentTimer->setInterval(UPDATE_DOCUMENT_DEFAULT_INTERVAL);
     m_updateDocumentTimer->setSingleShot(true);
     connect(m_q->document(), SIGNAL(contentsChanged()), m_updateDocumentTimer, SLOT(start()));
     connect(m_updateDocumentTimer, SIGNAL(timeout()), this, SLOT(reparseDocument()));
+    connect(modelManager, SIGNAL(documentUpdated(QmlJS::Document::Ptr)),
+            this, SLOT(onDocumentUpdated(QmlJS::Document::Ptr)));
+
+    // semantic info
+    m_semanticInfoUpdater = new SemanticInfoUpdater(this);
+    connect(m_semanticInfoUpdater, SIGNAL(updated(QmlJSTools::SemanticInfo)),
+            this, SLOT(acceptNewSemanticInfo(QmlJSTools::SemanticInfo)));
+    m_semanticInfoUpdater->start();
+
+    // library info changes
+    m_reupdateSemanticInfoTimer = new QTimer(this);
+    m_reupdateSemanticInfoTimer->setInterval(UPDATE_DOCUMENT_DEFAULT_INTERVAL);
+    m_reupdateSemanticInfoTimer->setSingleShot(true);
+    connect(m_reupdateSemanticInfoTimer, SIGNAL(timeout()), this, SLOT(reupdateSemanticInfo()));
+    connect(modelManager, SIGNAL(libraryInfoUpdated(QString,QmlJS::LibraryInfo)),
+            m_reupdateSemanticInfoTimer, SLOT(start()));
+}
+
+QmlJSEditorDocumentPrivate::~QmlJSEditorDocumentPrivate()
+{
+    m_semanticInfoUpdater->abort();
+    m_semanticInfoUpdater->wait();
 }
 
 void QmlJSEditorDocumentPrivate::invalidateFormatterCache()
 {
-    QmlJSTools::CreatorCodeFormatter formatter(m_q->tabSettings());
+    CreatorCodeFormatter formatter(m_q->tabSettings());
     formatter.invalidateCache(m_q->document());
 }
 
 void QmlJSEditorDocumentPrivate::reparseDocument()
 {
-    QmlJS::ModelManagerInterface::instance()->updateSourceFiles(QStringList() << m_q->filePath(),
+    ModelManagerInterface::instance()->updateSourceFiles(QStringList() << m_q->filePath(),
                                                                 false);
 }
 
+void QmlJSEditorDocumentPrivate::onDocumentUpdated(Document::Ptr doc)
+{
+    if (m_q->filePath() != doc->fileName())
+        return;
+
+    // text document has changed, simply wait for the next onDocumentUpdated
+    if (doc->editorRevision() != m_q->document()->revision())
+        return;
+
+    if (doc->ast()) {
+        // got a correctly parsed (or recovered) file.
+        m_semanticInfoDocRevision = doc->editorRevision();
+        m_semanticInfoUpdater->update(doc, ModelManagerInterface::instance()->snapshot());
+    }
+    emit m_q->updateCodeWarnings(doc);
+}
+
+void QmlJSEditorDocumentPrivate::reupdateSemanticInfo()
+{
+    // If the editor is newer than the semantic info (possibly with update in progress),
+    // new semantic infos won't be accepted anyway. We'll get a onDocumentUpdated anyhow.
+    if (m_q->document()->revision() != m_semanticInfoDocRevision)
+        return;
+
+    m_semanticInfoUpdater->reupdate(ModelManagerInterface::instance()->snapshot());
+}
+
+void QmlJSEditorDocumentPrivate::acceptNewSemanticInfo(const SemanticInfo &semanticInfo)
+{
+    if (semanticInfo.revision() != m_q->document()->revision()) {
+        // ignore outdated semantic infos
+        return;
+    }
+
+    m_semanticInfo = semanticInfo;
+    Document::Ptr doc = semanticInfo.document;
+
+    // create the ranges
+    CreateRanges createRanges;
+    m_semanticInfo.ranges = createRanges(m_q->document(), doc);
+
+    // Refresh the ids
+    FindIdDeclarations updateIds;
+    m_semanticInfo.idLocations = updateIds(doc);
+
+    emit m_q->semanticInfoUpdated(m_semanticInfo);
+}
+
 QmlJSEditorDocument::QmlJSEditorDocument()
     : m_d(new QmlJSEditorDocumentPrivate(this))
 {
@@ -82,3 +503,16 @@ QmlJSEditorDocument::~QmlJSEditorDocument()
 {
     delete m_d;
 }
+
+const SemanticInfo &QmlJSEditorDocument::semanticInfo() const
+{
+    return m_d->m_semanticInfo;
+}
+
+bool QmlJSEditorDocument::isSemanticInfoOutdated() const
+{
+    return m_d->m_semanticInfo.revision() != document()->revision();
+}
+
+} // Internal
+} // QmlJSEditor