File indexing completed on 2024-05-05 04:39:25

 /*
     SPDX-FileCopyrightText: 2020 Milian Wolff <mail@milianw.de>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "cmakefileapi.h"
 
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QJsonArray>
 #include <QVersionNumber>
 
 #include <makefileresolver/makefileresolver.h>
 
 #include "cmakeutils.h"
 #include "cmakeprojectdata.h"
 
 #include <debug.h>
 
 using namespace KDevelop;
 
 namespace {
 Path toCanonical(const Path& path)
 {
     QFileInfo info(path.toLocalFile());
     if (!info.exists())
         return path;
     const auto canonical = info.canonicalFilePath();
     if (info.filePath() != canonical) {
         return Path(canonical);
     } else {
         return path;
     }
 }
 
 QJsonObject parseFile(const QString& path)
 {
     QFile file(path);
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
         qCWarning(CMAKE) << "failed to read json file" << path << file.errorString();
         return {};
     }
     QJsonParseError error;
     const auto document = QJsonDocument::fromJson(file.readAll(), &error);
     if (error.error) {
         qCWarning(CMAKE) << "failed to parse json file" << path << error.errorString() << error.offset;
         return {};
     }
     return document.object();
 }
 
 bool isKDevelopClientResponse(const QJsonObject& indexObject)
 {
     return indexObject.value(QLatin1String("reply")).toObject().contains(QLatin1String("client-kdevelop"));
 }
 
 QString queryDirPath(const QString& buildDirectory)
 {
     return buildDirectory + QLatin1String("/.cmake/api/v1/query/client-kdevelop/");
 }
 
 QString queryFileName()
 {
     return QStringLiteral("query.json");
 }
 }
 
 namespace CMake {
 namespace FileApi {
 bool supported(const QString& cmakeExecutable)
 {
     return QVersionNumber::fromString(cmakeExecutableVersion(cmakeExecutable)) >= QVersionNumber(3, 14);
 }
 
 void writeClientQueryFile(const QString& buildDirectory)
 {
     const QDir queryDir(queryDirPath(buildDirectory));
     if (!queryDir.exists() && !queryDir.mkpath(QStringLiteral("."))) {
         qCWarning(CMAKE) << "failed to create file API query dir:" << queryDir.absolutePath();
         return;
     }
 
     QFile queryFile(queryDir.absoluteFilePath(queryFileName()));
     if (!queryFile.open(QIODevice::WriteOnly | QIODevice::Text)) {
         qCWarning(CMAKE) << "failed to open query file for writing:" << queryFile.fileName() << queryFile.errorString();
         return;
     }
 
     // Pad output with spaces to align the printed timestamp with others and facilitate comparison.
     qCDebug(CMAKE) << "writing API client query file at    " << PrintLastModified{nullptr, QDateTime::currentDateTime()}
                    << "- within" << buildDirectory;
 
     queryFile.write(R"({"requests": [{"kind": "codemodel", "version": 2}, {"kind": "cmakeFiles", "version": 1}]})");
 }
 
 static QDir toReplyDir(const QString& buildDirectory)
 {
     QDir replyDir(buildDirectory + QLatin1String("/.cmake/api/v1/reply/"));
     if (!replyDir.exists()) {
         qCWarning(CMAKE) << "cmake-file-api reply directory does not exist:" << replyDir.path();
     }
     return replyDir;
 }
 
 ReplyIndex findReplyIndexFile(const QString& buildDirectory)
 {
     const QFileInfo cmakeCacheInfo(buildDirectory + QLatin1String{"/CMakeCache.txt"});
     if (!cmakeCacheInfo.isFile()) {
         // don't import data when no suitable CMakeCache file exists, which could happen
         // because our prune job didn't use to delete the .cmake folder
         qCDebug(CMAKE) << "no CMakeCache.txt found in" << cmakeCacheInfo.absolutePath();
         return {};
     }
 
     const QFileInfo queryInfo(queryDirPath(buildDirectory) + queryFileName());
     if (!queryInfo.isFile()) {
         qCWarning(CMAKE) << "no API client query file found at" << queryInfo.absoluteFilePath();
         return {};
     }
 
     const auto isReplyOutdated = [&buildDirectory, &cmakeCacheInfo](const QDateTime& queryLastModified,
                                                                     const QDateTime& replyLastModified) {
         qCDebug(CMAKE) << PrintLastModified{"API client query file", queryLastModified} << "- within" << buildDirectory;
         qCDebug(CMAKE) << PrintLastModified{"API reply index file", replyLastModified} << "- within" << buildDirectory;
         if (replyLastModified < queryLastModified) {
             qCDebug(CMAKE) << "API reply index file is out of date (last modified before the client query file)";
             return true;
         }
 
         const auto cmakeCacheLastModified = cmakeCacheInfo.lastModified();
         qCDebug(CMAKE) << PrintLastModified{"CMakeCache.txt", cmakeCacheLastModified} << "- within" << buildDirectory;
         // CMakeCache.txt can be modified during the CMake configure step - after KDevelop modifies the API
         // client query file. The API reply index file is always modified during the CMake generate step.
         if (replyLastModified < cmakeCacheLastModified) {
             qCDebug(CMAKE) << "API reply index file is out of date (last modified before CMakeCache.txt)";
             return true;
         }
 
         return false;
     };
 
     const auto replyDir = toReplyDir(buildDirectory);
     const auto fileList =
         replyDir.entryInfoList({QStringLiteral("index-*.json")}, QDir::Files, QDir::Name | QDir::Reversed);
     for (const auto& entry : fileList) {
         const auto object = parseFile(entry.absoluteFilePath());
         if (isKDevelopClientResponse(object)) {
             ReplyIndex result{queryInfo.lastModified(), object};
             if (isReplyOutdated(result.queryLastModified, entry.lastModified())) {
                 result.markOutdated();
             }
             return result;
         }
     }
     qCWarning(CMAKE) << "no cmake-file-api reply index file found in" << replyDir.absolutePath();
     return {};
 }
 
 static CMakeTarget parseTarget(const QJsonObject& target, StringInterner& stringInterner,
                                PathInterner& sourcePathInterner, PathInterner& buildPathInterner,
                                CMakeFilesCompilationData& compilationData)
 {
     CMakeTarget ret;
     ret.name = target.value(QLatin1String("name")).toString();
     ret.type = CMakeTarget::typeToEnum(target.value(QLatin1String("type")).toString());
     ret.folder = target.value(QLatin1String("folder")).toObject().value(QLatin1String("name")).toString();
 
     for (const auto& jsonArtifact : target.value(QLatin1String("artifacts")).toArray()) {
         const auto artifact = jsonArtifact.toObject();
         const auto buildPath = buildPathInterner.internPath(artifact.value(QLatin1String("path")).toString());
         if (buildPath.isValid()) {
             ret.artifacts.append(buildPath);
         }
     }
 
     for (const auto& jsonSource : target.value(QLatin1String("sources")).toArray()) {
         const auto source = jsonSource.toObject();
         const auto sourcePath = sourcePathInterner.internPath(source.value(QLatin1String("path")).toString());
         if (sourcePath.isValid()) {
             ret.sources.append(sourcePath);
         }
     }
 
     QVector<CMakeFile> compileGroups;
     for (const auto& jsonCompileGroup : target.value(QLatin1String("compileGroups")).toArray()) {
         CMakeFile cmakeFile;
         const auto compileGroup = jsonCompileGroup.toObject();
 
         cmakeFile.language = compileGroup.value(QLatin1String("language")).toString();
 
         for (const auto& jsonFragment : compileGroup.value(QLatin1String("compileCommandFragments")).toArray()) {
             const auto fragment = jsonFragment.toObject();
             cmakeFile.compileFlags += fragment.value(QLatin1String("fragment")).toString();
             cmakeFile.compileFlags += QLatin1Char(' ');
         }
         cmakeFile.compileFlags = stringInterner.internString(cmakeFile.compileFlags);
 
         for (const auto& jsonDefine : compileGroup.value(QLatin1String("defines")).toArray()) {
             const auto define = jsonDefine.toObject();
             cmakeFile.addDefine(define.value(QLatin1String("define")).toString());
         }
         cmakeFile.defines = MakeFileResolver::extractDefinesFromCompileFlags(cmakeFile.compileFlags, stringInterner, cmakeFile.defines);
 
         for (const auto& jsonInclude : compileGroup.value(QLatin1String("includes")).toArray()) {
             const auto include = jsonInclude.toObject(); 
             const auto path = sourcePathInterner.internPath(include.value(QLatin1String("path")).toString());
             if (path.isValid()) {
                 cmakeFile.includes.append(path);
             }
         }
 
         compileGroups.append(cmakeFile);
     }
 
     for (const auto& jsonSource : target.value(QLatin1String("sources")).toArray()) {
         const auto source = jsonSource.toObject();
         const auto compileGroupIndex = source.value(QLatin1String("compileGroupIndex")).toInt(-1);
         if (compileGroupIndex < 0 || compileGroupIndex > compileGroups.size()) {
             continue;
         }
         const auto compileGroup = compileGroups.value(compileGroupIndex);
         const auto path = sourcePathInterner.internPath(source.value(QLatin1String("path")).toString());
         if (path.isValid()) {
             compilationData.files[toCanonical(path)] = compileGroup;
         }
     }
     return ret;
 }
 
 static CMakeProjectData parseCodeModel(const QJsonObject& codeModel, const QDir& replyDir,
                                        StringInterner&stringInterner, PathInterner& sourcePathInterner, PathInterner& buildPathInterner)
 {
     CMakeProjectData ret;
     // for now, we only use the first available configuration and don't support multi configurations
     const auto configuration = codeModel.value(QLatin1String("configurations")).toArray().at(0).toObject();
     const auto targets = configuration.value(QLatin1String("targets")).toArray();
     const auto directories = configuration.value(QLatin1String("directories")).toArray();
     for (const auto& directoryValue : directories) {
         const auto directory = directoryValue.toObject();
         if (!directory.contains(QLatin1String("targetIndexes"))) {
             continue;
         }
         const auto dirSourcePath = sourcePathInterner.internPath(directory.value(QLatin1String("source")).toString());
         auto& dirTargets = ret.targets[dirSourcePath];
         for (const auto& targetIndex : directory.value(QLatin1String("targetIndexes")).toArray()) {
             const auto jsonTarget = targets.at(targetIndex.toInt(-1)).toObject();
             if (jsonTarget.isEmpty()) {
                 continue;
             }
             const auto targetFile = jsonTarget.value(QLatin1String("jsonFile")).toString();
             const auto target = parseTarget(parseFile(replyDir.absoluteFilePath(targetFile)),
                                             stringInterner, sourcePathInterner, buildPathInterner,
                                             ret.compilationData);
             if (target.name.isEmpty()) {
                 continue;
             }
             dirTargets.append(target);
         }
     }
     ret.compilationData.isValid = !codeModel.isEmpty();
     ret.compilationData.rebuildFileForFolderMapping();
     if (!ret.compilationData.isValid) {
         qCWarning(CMAKE) << "failed to parse code model" << codeModel;
     }
     return ret;
 }
 
 /// @return source CMake files (e.g. CMakeLists.txt, *.cmake), modifying which should trigger reloading the project.
 static QSet<Path> parseCMakeFiles(const QJsonObject& cmakeFiles, PathInterner& sourcePathInterner,
                                   QDateTime* lastModifiedCMakeFile)
 {
     Q_ASSERT(lastModifiedCMakeFile);
     QSet<Path> ret;
     for (const auto& jsonInput : cmakeFiles.value(QLatin1String("inputs")).toArray()) {
         const auto input = jsonInput.toObject();
         const auto path = sourcePathInterner.internPath(input.value(QLatin1String("path")).toString());
         const auto isGenerated = input.value(QLatin1String("isGenerated")).toBool();
         const auto isExternal = input.value(QLatin1String("isExternal")).toBool();
 
         // Generated CMake files can be modified during the CMake configure step - after KDevelop
         // modifies the API client query file. Don't take into account last modified timestamps of
         // generated files to prevent wrongly considering up-to-date data outdated. The user is
         // not supposed to modify the generated files manually, so ignoring them should be fine.
         if (!isGenerated && path.isLocalFile()) {
             const auto info = QFileInfo(path.toLocalFile());
             *lastModifiedCMakeFile = std::max(info.lastModified(), *lastModifiedCMakeFile);
         }
 
         // Reloading the project when a generated CMake file is changed can cause a reload loop, and the user is not
         // supposed to modify the generated files manually. External files are not under the top-level source or build
         // directories, so AbstractFileManagerPlugin::projectWatcher() never watches them. Watching each individual
         // external CMake file can be costly and cause issues elsewhere if a watched item count limit is reached.
         if (!isGenerated && !isExternal) {
             ret.insert(path);
         }
     }
     return ret;
 }
 
 CMakeProjectData parseReplyIndexFile(const ReplyIndex& replyIndex, const Path& sourceDirectory,
                                      const Path& buildDirectory)
 {
     const auto reply = replyIndex.data.value(QLatin1String("reply")).toObject();
     const auto clientKDevelop = reply.value(QLatin1String("client-kdevelop")).toObject();
     const auto query = clientKDevelop.value(QLatin1String("query.json")).toObject();
     const auto responses = query.value(QLatin1String("responses")).toArray();
     const auto replyDir = toReplyDir(buildDirectory.toLocalFile());
 
     StringInterner stringInterner;
     PathInterner sourcePathInterner(toCanonical(sourceDirectory));
     PathInterner buildPathInterner(buildDirectory);
 
     CMakeProjectData codeModel;
     QSet<Path> cmakeFiles;
 
     bool isOutdated = true; // consider the data outdated if the cmakeFiles object is absent or replyIndex is outdated
     for (const auto& responseValue : responses) {
         const auto response = responseValue.toObject();
         const auto kind = response.value(QLatin1String("kind"));
         const auto jsonFile = response.value(QLatin1String("jsonFile")).toString();
         const auto jsonFilePath = replyDir.absoluteFilePath(jsonFile);
         if (kind == QLatin1String("codemodel")) {
             codeModel = parseCodeModel(parseFile(jsonFilePath), replyDir,
                                        stringInterner, sourcePathInterner, buildPathInterner);
             if (!codeModel.compilationData.isValid) {
                 break; // skip to printing a warning and the early return under the loop
             }
         } else if (kind == QLatin1String("cmakeFiles")) {
             QDateTime lastModifiedCMakeFile;
             cmakeFiles = parseCMakeFiles(parseFile(jsonFilePath), sourcePathInterner, &lastModifiedCMakeFile);
             qCDebug(CMAKE) << PrintLastModified{"source CMake file", lastModifiedCMakeFile} << "- within"
                            << buildDirectory;
             if (!replyIndex.isOutdated()) {
                 // KDevelop always writes the API client query file shortly before running the CMake configure step.
                 // Use its last modified timestamp as the time when the last CMake configure step started. This
                 // timestamp is normally a slight underestimate. However, when the user runs the CMake configure step
                 // manually while KDevelop is not running, the API client query file is not touched. Up-to-date project
                 // data can be marked outdated here in this case. KDevelop would reconfigure CMake needlessly then.
                 // TODO: determine when the last CMake configure step started more reliably, even if KDevelop is not
                 // running at the time. KDevelop always writes the same API client query, so the API reply written by
                 // CMake during the generate step is correct even if KDevelop does not rewrite the query file. If a
                 // future KDevelop version changes its API client query, the query file contents can be read and
                 // compared to determine whether the API reply is correct.
                 isOutdated = replyIndex.queryLastModified < lastModifiedCMakeFile;
                 if (isOutdated) {
                     qCDebug(CMAKE) << "API client query file is out of date (last modified before a source CMake file)";
                 }
             }
         }
     }
 
     if (!codeModel.compilationData.isValid) {
         qCWarning(CMAKE) << "failed to find code model in reply index" << sourceDirectory << buildDirectory
                          << replyIndex.data;
         return {};
     }
 
     codeModel.isOutdated = isOutdated;
     codeModel.cmakeFiles = cmakeFiles;
     return codeModel;
 }
 }
 }