diff --git a/src/libs/qmljs/qmljsmodelmanagerinterface.cpp b/src/libs/qmljs/qmljsmodelmanagerinterface.cpp
index fbd2339105c..41fc3958983 100644
--- a/src/libs/qmljs/qmljsmodelmanagerinterface.cpp
+++ b/src/libs/qmljs/qmljsmodelmanagerinterface.cpp
@@ -32,6 +32,7 @@
 #include "qmljstypedescriptionreader.h"
 #include "qmljsdialect.h"
 #include "qmljsviewercontext.h"
+#include "qmljsutils.h"
 
 #include <cplusplus/cppmodelmanagerbase.h>
 #include <utils/algorithm.h>
@@ -811,33 +812,11 @@ static bool findNewQmlLibraryInPath(const QString &path,
     return true;
 }
 
-static void findNewQmlLibrary(
-    const QString &path,
-    const LanguageUtils::ComponentVersion &version,
-    const Snapshot &snapshot,
-    ModelManagerInterface *modelManager,
-    QStringList *importedFiles,
-    QSet<QString> *scannedPaths,
-    QSet<QString> *newLibraries)
+static QString modulePath(const ImportInfo &import, const QStringList &paths)
 {
-    QString libraryPath = QString::fromLatin1("%1.%2.%3").arg(
-                path,
-                QString::number(version.majorVersion()),
-                QString::number(version.minorVersion()));
-    findNewQmlLibraryInPath(
-                libraryPath, snapshot, modelManager,
-                importedFiles, scannedPaths, newLibraries, false);
-
-    libraryPath = QString::fromLatin1("%1.%2").arg(
-                path,
-                QString::number(version.majorVersion()));
-    findNewQmlLibraryInPath(
-                libraryPath, snapshot, modelManager,
-                importedFiles, scannedPaths, newLibraries, false);
-
-    findNewQmlLibraryInPath(
-                path, snapshot, modelManager,
-                importedFiles, scannedPaths, newLibraries, false);
+    if (!import.version().isValid())
+        return QString();
+    return modulePath(import.name(), import.version().toString(), paths);
 }
 
 static void findNewLibraryImports(const Document::Ptr &doc, const Snapshot &snapshot,
@@ -849,7 +828,7 @@ static void findNewLibraryImports(const Document::Ptr &doc, const Snapshot &snap
                             importedFiles, scannedPaths, newLibraries, false);
 
     // scan dir and lib imports
-    const PathsAndLanguages importPaths = modelManager->importPaths();
+    const QStringList importPaths = modelManager->importPathsNames();
     foreach (const ImportInfo &import, doc->bind()->imports()) {
         if (import.type() == ImportType::Directory) {
             const QString targetPath = import.path();
@@ -858,13 +837,11 @@ static void findNewLibraryImports(const Document::Ptr &doc, const Snapshot &snap
         }
 
         if (import.type() == ImportType::Library) {
-            if (!import.version().isValid())
+            const QString libraryPath = modulePath(import, importPaths);
+            if (libraryPath.isEmpty())
                 continue;
-            foreach (const PathAndLanguage &importPath, importPaths) {
-                const QString targetPath = importPath.path().appendPath(import.path()).toString();
-                findNewQmlLibrary(targetPath, import.version(), snapshot, modelManager,
-                                  importedFiles, scannedPaths, newLibraries);
-            }
+            findNewQmlLibraryInPath(libraryPath, snapshot, modelManager, importedFiles,
+                                    scannedPaths, newLibraries, false);
         }
     }
 }
@@ -1071,10 +1048,14 @@ void ModelManagerInterface::importScan(QFutureInterface<void> &future,
     }
 }
 
-PathsAndLanguages ModelManagerInterface::importPaths() const
+QStringList ModelManagerInterface::importPathsNames() const
 {
+    QStringList names;
     QMutexLocker l(&m_mutex);
-    return m_allImportPaths;
+    names.reserve(m_allImportPaths.size());
+    for (const PathAndLanguage &x: m_allImportPaths)
+        names << x.path().toString();
+    return names;
 }
 
 QmlLanguageBundles ModelManagerInterface::activeBundles() const
diff --git a/src/libs/qmljs/qmljsmodelmanagerinterface.h b/src/libs/qmljs/qmljsmodelmanagerinterface.h
index c86177d4879..430f4b880e6 100644
--- a/src/libs/qmljs/qmljsmodelmanagerinterface.h
+++ b/src/libs/qmljs/qmljsmodelmanagerinterface.h
@@ -178,7 +178,7 @@ public:
     QList<ProjectInfo> allProjectInfosForPath(const QString &path) const;
     bool isIdle() const ;
 
-    PathsAndLanguages importPaths() const;
+    QStringList importPathsNames() const;
     QmlJS::QmlLanguageBundles activeBundles() const;
     QmlJS::QmlLanguageBundles extendedBundles() const;
 
diff --git a/src/libs/qmljs/qmljsplugindumper.cpp b/src/libs/qmljs/qmljsplugindumper.cpp
index c5ba42c13e1..7ada84f28b8 100644
--- a/src/libs/qmljs/qmljsplugindumper.cpp
+++ b/src/libs/qmljs/qmljsplugindumper.cpp
@@ -25,6 +25,7 @@
 
 #include "qmljsplugindumper.h"
 #include "qmljsmodelmanagerinterface.h"
+#include "qmljsutils.h"
 
 #include <qmljs/qmljsinterpreter.h>
 #include <qmljs/qmljsviewercontext.h>
@@ -401,48 +402,35 @@ void PluginDumper::loadQmlTypeDescription(const QStringList &paths,
 /*!
  * \brief Build the path of an existing qmltypes file from a module name.
  * \param name
- * \return the module's qmltypes file path
+ * \return the module's qmltypes file path or an empty string if not found
  *
  * Look for \a name qmltypes file in model manager's import paths.
- * For each import path the following files are searched, in this order:
- *
- *   - <name>.<major>.<minor>/plugins.qmltypes
- *   - <name>.<major>/plugins.qmltypes
- *   - <name>/plugins.qmltypes
- *
- * That means that a more qualified directory name has precedence over a
- * less qualified one.  Be aware that the import paths order has a stronger
- * precedence, so a less qualified name could shadow a more qualified one if
- * it resides in a different import path.
  *
+ * \sa QmlJs::modulePath
  * \sa LinkPrivate::importNonFile
  */
 QString PluginDumper::buildQmltypesPath(const QString &name) const
 {
     QString qualifiedName;
-    QString majorVersion;
-    QString minorVersion;
+    QString version;
 
     QRegularExpression import("^(?<name>[\\w|\\.]+)\\s+(?<major>\\d+)\\.(?<minor>\\d+)$");
     QRegularExpressionMatch m = import.match(name);
     if (m.hasMatch()) {
         qualifiedName = m.captured("name");
-        majorVersion = m.captured("major");
-        minorVersion = m.captured("minor");
+        version = m.captured("major") + QLatin1Char('.') + m.captured("minor");
     }
 
-    for (const PathAndLanguage &p: m_modelManager->importPaths()) {
-        QString moduleName = qualifiedName.replace(QLatin1Char('.'), QLatin1Char('/'));
-        QString moduleNameMajor = moduleName + QLatin1Char('.') + majorVersion;
-        QString moduleNameMajorMinor = moduleNameMajor + QLatin1Char('.') + minorVersion;
+    const QString path = modulePath(qualifiedName, version, m_modelManager->importPathsNames());
+
+    if (path.isEmpty())
+        return QString();
+
+    const QString filename = path + QLatin1String("/plugins.qmltypes");
+
+    if (QFile::exists(filename))
+        return filename;
 
-        for (const auto n: QStringList{moduleNameMajorMinor, moduleNameMajor, moduleName}) {
-            QString filename(p.path().toString() + QLatin1Char('/') + n
-                             + QLatin1String("/plugins.qmltypes"));
-            if (QFile::exists(filename))
-                return filename;
-        }
-    }
     return QString();
 }