mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
6ef79c4ba0
Instead of the code querying the compiler's built-in Clang instance, refactor the dependency scanner to explicitly keep track of module output path. It is still set according to '-module-cache-path' as it has been prior to this change, but now the scanner can use a different module cache for scanning PCMs, as specified with '-clang-scanner-module-cache-path', without affecting module output path. Resolves rdar://113222853
304 lines
13 KiB
C++
304 lines
13 KiB
C++
//===--- ModuleDependencyScanner.cpp - Compute module dependencies --------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "swift/AST/ASTContext.h"
|
|
#include "swift/AST/DiagnosticSuppression.h"
|
|
#include "swift/AST/DiagnosticsFrontend.h"
|
|
#include "swift/AST/ModuleDependencies.h"
|
|
#include "swift/AST/SourceFile.h"
|
|
#include "swift/AST/TypeCheckRequests.h"
|
|
#include "swift/AST/SourceFile.h"
|
|
#include "swift/Basic/FileTypes.h"
|
|
#include "swift/Frontend/ModuleInterfaceLoader.h"
|
|
#include "swift/Serialization/SerializedModuleLoader.h"
|
|
#include "swift/Serialization/ModuleDependencyScanner.h"
|
|
#include "swift/Subsystems.h"
|
|
#include "llvm/ADT/IntrusiveRefCntPtr.h"
|
|
#include "llvm/CAS/CachingOnDiskFileSystem.h"
|
|
#include "llvm/Support/Error.h"
|
|
#include "llvm/Support/VirtualFileSystem.h"
|
|
#include "ModuleFileSharedCore.h"
|
|
|
|
#include <algorithm>
|
|
using namespace swift;
|
|
using llvm::ErrorOr;
|
|
|
|
std::error_code ModuleDependencyScanner::findModuleFilesInDirectory(
|
|
ImportPath::Element ModuleID, const SerializedModuleBaseName &BaseName,
|
|
SmallVectorImpl<char> *ModuleInterfacePath,
|
|
SmallVectorImpl<char> *ModuleInterfaceSourcePath,
|
|
std::unique_ptr<llvm::MemoryBuffer> *ModuleBuffer,
|
|
std::unique_ptr<llvm::MemoryBuffer> *ModuleDocBuffer,
|
|
std::unique_ptr<llvm::MemoryBuffer> *ModuleSourceInfoBuffer,
|
|
bool skipBuildingInterface, bool IsFramework,
|
|
bool isTestableDependencyLookup) {
|
|
using namespace llvm::sys;
|
|
|
|
auto &fs = *Ctx.SourceMgr.getFileSystem();
|
|
|
|
auto ModPath = BaseName.getName(file_types::TY_SwiftModuleFile);
|
|
auto InPath = BaseName.getName(file_types::TY_SwiftModuleInterfaceFile);
|
|
|
|
if (LoadMode == ModuleLoadingMode::OnlySerialized || !fs.exists(InPath)) {
|
|
if (fs.exists(ModPath)) {
|
|
// The module file will be loaded directly.
|
|
auto dependencies = scanModuleFile(ModPath, IsFramework);
|
|
if (dependencies) {
|
|
this->dependencies = std::move(dependencies.get());
|
|
return std::error_code();
|
|
}
|
|
return dependencies.getError();
|
|
} else {
|
|
return std::make_error_code(std::errc::no_such_file_or_directory);
|
|
}
|
|
}
|
|
assert(fs.exists(InPath));
|
|
|
|
// Use the private interface file if exits.
|
|
auto PrivateInPath =
|
|
BaseName.getName(file_types::TY_PrivateSwiftModuleInterfaceFile);
|
|
if (fs.exists(PrivateInPath)) {
|
|
InPath = PrivateInPath;
|
|
}
|
|
auto dependencies = scanInterfaceFile(InPath, IsFramework,
|
|
isTestableDependencyLookup);
|
|
if (dependencies) {
|
|
this->dependencies = std::move(dependencies.get());
|
|
return std::error_code();
|
|
}
|
|
|
|
return dependencies.getError();
|
|
}
|
|
|
|
bool PlaceholderSwiftModuleScanner::findModule(
|
|
ImportPath::Element moduleID, SmallVectorImpl<char> *moduleInterfacePath,
|
|
SmallVectorImpl<char> *moduleInterfaceSourcePath,
|
|
std::unique_ptr<llvm::MemoryBuffer> *moduleBuffer,
|
|
std::unique_ptr<llvm::MemoryBuffer> *moduleDocBuffer,
|
|
std::unique_ptr<llvm::MemoryBuffer> *moduleSourceInfoBuffer,
|
|
bool skipBuildingInterface, bool isTestableDependencyLookup,
|
|
bool &isFramework, bool &isSystemModule) {
|
|
StringRef moduleName = Ctx.getRealModuleName(moduleID.Item).str();
|
|
auto it = PlaceholderDependencyModuleMap.find(moduleName);
|
|
if (it == PlaceholderDependencyModuleMap.end()) {
|
|
return false;
|
|
}
|
|
auto &moduleInfo = it->getValue();
|
|
auto dependencies = ModuleDependencyInfo::forPlaceholderSwiftModuleStub(
|
|
moduleInfo.modulePath,
|
|
moduleInfo.moduleDocPath.has_value() ?
|
|
moduleInfo.moduleDocPath.value() : "",
|
|
moduleInfo.moduleSourceInfoPath.has_value() ?
|
|
moduleInfo.moduleSourceInfoPath.value() : "");
|
|
this->dependencies = std::move(dependencies);
|
|
return true;
|
|
}
|
|
|
|
static std::vector<std::string> getCompiledCandidates(ASTContext &ctx,
|
|
StringRef moduleName,
|
|
StringRef interfacePath) {
|
|
return ctx.getModuleInterfaceChecker()->getCompiledModuleCandidatesForInterface(
|
|
moduleName.str(), interfacePath);
|
|
}
|
|
|
|
ErrorOr<ModuleDependencyInfo> ModuleDependencyScanner::scanInterfaceFile(
|
|
Twine moduleInterfacePath, bool isFramework, bool isTestableImport) {
|
|
// Create a module filename.
|
|
// FIXME: Query the module interface loader to determine an appropriate
|
|
// name for the module, which includes an appropriate hash.
|
|
auto newExt = file_types::getExtension(file_types::TY_SwiftModuleFile);
|
|
auto realModuleName = Ctx.getRealModuleName(moduleName);
|
|
llvm::SmallString<32> modulePath = realModuleName.str();
|
|
llvm::sys::path::replace_extension(modulePath, newExt);
|
|
llvm::Optional<ModuleDependencyInfo> Result;
|
|
|
|
// FIXME: Consider not spawning a sub-instance for this
|
|
std::error_code code =
|
|
astDelegate.runInSubContext(realModuleName.str(),
|
|
moduleInterfacePath.str(),
|
|
StringRef(),
|
|
SourceLoc(),
|
|
[&](ASTContext &Ctx, ModuleDecl *mainMod,
|
|
ArrayRef<StringRef> BaseArgs,
|
|
ArrayRef<StringRef> PCMArgs, StringRef Hash) {
|
|
assert(mainMod);
|
|
std::string InPath = moduleInterfacePath.str();
|
|
auto compiledCandidates = getCompiledCandidates(Ctx, realModuleName.str(),
|
|
InPath);
|
|
std::vector<std::string> Args(BaseArgs.begin(), BaseArgs.end());
|
|
|
|
// Add explicit Swift dependency compilation flags
|
|
Args.push_back("-explicit-interface-module-build");
|
|
Args.push_back("-disable-implicit-swift-modules");
|
|
Args.push_back("-Xcc"); Args.push_back("-fno-implicit-modules");
|
|
Args.push_back("-Xcc"); Args.push_back("-fno-implicit-module-maps");
|
|
for (const auto &candidate : compiledCandidates) {
|
|
Args.push_back("-candidate-module-file");
|
|
Args.push_back(candidate);
|
|
}
|
|
|
|
// Compute the output path and add it to the command line
|
|
SmallString<128> outputPathBase(moduleOutputPath);
|
|
llvm::sys::path::append(
|
|
outputPathBase,
|
|
moduleName.str() + "-" + Hash + "." +
|
|
file_types::getExtension(file_types::TY_SwiftModuleFile));
|
|
Args.push_back("-o");
|
|
Args.push_back(outputPathBase.str().str());
|
|
|
|
// Open the interface file.
|
|
auto &fs = *Ctx.SourceMgr.getFileSystem();
|
|
auto interfaceBuf = fs.getBufferForFile(moduleInterfacePath);
|
|
if (!interfaceBuf) {
|
|
return interfaceBuf.getError();
|
|
}
|
|
|
|
// Create a source file.
|
|
unsigned bufferID = Ctx.SourceMgr.addNewSourceBuffer(std::move(interfaceBuf.get()));
|
|
auto moduleDecl = ModuleDecl::create(realModuleName, Ctx);
|
|
|
|
SourceFile::ParsingOptions parsingOpts;
|
|
auto sourceFile = new (Ctx) SourceFile(
|
|
*moduleDecl, SourceFileKind::Interface, bufferID, parsingOpts);
|
|
moduleDecl->addAuxiliaryFile(*sourceFile);
|
|
|
|
std::string RootID;
|
|
if (dependencyTracker) {
|
|
dependencyTracker->startTracking();
|
|
dependencyTracker->addCommonSearchPathDeps(Ctx.SearchPathOpts);
|
|
std::vector<std::string> clangDependencyFiles;
|
|
auto clangImporter =
|
|
static_cast<ClangImporter *>(Ctx.getClangModuleLoader());
|
|
clangImporter->addClangInvovcationDependencies(clangDependencyFiles);
|
|
llvm::for_each(clangDependencyFiles, [&](std::string &file) {
|
|
dependencyTracker->trackFile(file);
|
|
});
|
|
dependencyTracker->trackFile(moduleInterfacePath);
|
|
auto RootOrError = dependencyTracker->createTreeFromDependencies();
|
|
if (!RootOrError)
|
|
return llvm::errorToErrorCode(RootOrError.takeError());
|
|
RootID = RootOrError->getID().toString();
|
|
}
|
|
|
|
std::vector<StringRef> ArgsRefs(Args.begin(), Args.end());
|
|
Result = ModuleDependencyInfo::forSwiftInterfaceModule(
|
|
outputPathBase.str().str(), InPath, compiledCandidates, ArgsRefs,
|
|
PCMArgs, Hash, isFramework, RootID, /*module-cache-key*/ "");
|
|
|
|
// Walk the source file to find the import declarations.
|
|
llvm::StringSet<> alreadyAddedModules;
|
|
Result->addModuleImport(*sourceFile, alreadyAddedModules);
|
|
|
|
// Collect implicitly imported modules in case they are not explicitly
|
|
// printed in the interface file, e.g. SwiftOnoneSupport.
|
|
auto &imInfo = mainMod->getImplicitImportInfo();
|
|
for (auto import: imInfo.AdditionalUnloadedImports) {
|
|
Result->addModuleImport(import.module.getModulePath(), &alreadyAddedModules);
|
|
}
|
|
|
|
// For a `@testable` direct dependency, read in the dependencies
|
|
// from an adjacent binary module, for completeness.
|
|
if (isTestableImport) {
|
|
auto adjacentBinaryModule = std::find_if(
|
|
compiledCandidates.begin(), compiledCandidates.end(),
|
|
[moduleInterfacePath](const std::string &candidate) {
|
|
return llvm::sys::path::parent_path(candidate) ==
|
|
llvm::sys::path::parent_path(moduleInterfacePath.str());
|
|
});
|
|
if (adjacentBinaryModule != compiledCandidates.end()) {
|
|
// Required modules.
|
|
auto adjacentBinaryModuleRequiredImports = getImportsOfModule(
|
|
*adjacentBinaryModule, ModuleLoadingBehavior::Required, isFramework,
|
|
isRequiredOSSAModules(), Ctx.LangOpts.SDKName,
|
|
Ctx.LangOpts.PackageName, Ctx.SourceMgr.getFileSystem().get(),
|
|
Ctx.SearchPathOpts.DeserializedPathRecoverer);
|
|
if (!adjacentBinaryModuleRequiredImports)
|
|
return adjacentBinaryModuleRequiredImports.getError();
|
|
auto adjacentBinaryModuleRequiredModuleImports =
|
|
(*adjacentBinaryModuleRequiredImports).moduleImports;
|
|
#ifndef NDEBUG
|
|
// Verify that the set of required modules read out from the binary
|
|
// module is a super-set of module imports identified in the
|
|
// textual interface.
|
|
for (const auto &requiredImport : Result->getModuleImports()) {
|
|
assert(adjacentBinaryModuleRequiredModuleImports.contains(requiredImport) &&
|
|
"Expected adjacent binary module's import set to contain all "
|
|
"textual interface imports.");
|
|
}
|
|
#endif
|
|
|
|
for (const auto &requiredImport : adjacentBinaryModuleRequiredModuleImports)
|
|
Result->addModuleImport(requiredImport.getKey(),
|
|
&alreadyAddedModules);
|
|
|
|
// Optional modules. Will be looked-up on a best-effort basis
|
|
auto adjacentBinaryModuleOptionalImports = getImportsOfModule(
|
|
*adjacentBinaryModule, ModuleLoadingBehavior::Optional, isFramework,
|
|
isRequiredOSSAModules(), Ctx.LangOpts.SDKName,
|
|
Ctx.LangOpts.PackageName, Ctx.SourceMgr.getFileSystem().get(),
|
|
Ctx.SearchPathOpts.DeserializedPathRecoverer);
|
|
if (!adjacentBinaryModuleOptionalImports)
|
|
return adjacentBinaryModuleOptionalImports.getError();
|
|
auto adjacentBinaryModuleOptionalModuleImports =
|
|
(*adjacentBinaryModuleOptionalImports).moduleImports;
|
|
for (const auto &optionalImport : adjacentBinaryModuleOptionalModuleImports)
|
|
Result->addOptionalModuleImport(optionalImport.getKey(),
|
|
&alreadyAddedModules);
|
|
}
|
|
}
|
|
|
|
return std::error_code();
|
|
});
|
|
|
|
if (code) {
|
|
return code;
|
|
}
|
|
return *Result;
|
|
}
|
|
|
|
llvm::Optional<const ModuleDependencyInfo *>
|
|
SerializedModuleLoaderBase::getModuleDependencies(
|
|
StringRef moduleName, ModuleDependenciesCache &cache,
|
|
InterfaceSubContextDelegate &delegate, bool isTestableDependencyLookup) {
|
|
ImportPath::Module::Builder builder(Ctx, moduleName, /*separator=*/'.');
|
|
auto modulePath = builder.get();
|
|
auto moduleId = modulePath.front().Item;
|
|
// Instantiate dependency scanning "loaders".
|
|
SmallVector<std::unique_ptr<ModuleDependencyScanner>, 2> scanners;
|
|
// Placeholder dependencies must be resolved first, to prevent the
|
|
// ModuleDependencyScanner from first discovering artifacts of a previous
|
|
// build. Such artifacts are captured as compiledModuleCandidates in the
|
|
// dependency graph of the placeholder dependency module itself.
|
|
// FIXME: submodules?
|
|
scanners.push_back(std::make_unique<PlaceholderSwiftModuleScanner>(
|
|
Ctx, LoadMode, moduleId, Ctx.SearchPathOpts.PlaceholderDependencyModuleMap,
|
|
delegate, cache.getModuleOutputPath(),
|
|
cache.getScanService().createSwiftDependencyTracker()));
|
|
scanners.push_back(std::make_unique<ModuleDependencyScanner>(
|
|
Ctx, LoadMode, moduleId, delegate, cache.getModuleOutputPath(),
|
|
ModuleDependencyScanner::MDS_plain,
|
|
cache.getScanService().createSwiftDependencyTracker()));
|
|
|
|
// Check whether there is a module with this name that we can import.
|
|
assert(isa<PlaceholderSwiftModuleScanner>(scanners[0].get()) &&
|
|
"Expected PlaceholderSwiftModuleScanner as the first dependency scanner loader.");
|
|
for (auto &scanner : scanners) {
|
|
if (scanner->canImportModule(modulePath, nullptr, isTestableDependencyLookup)) {
|
|
// Record the dependencies.
|
|
cache.recordDependency(moduleName, *(scanner->dependencies));
|
|
return cache.findDependency(moduleName, scanner->dependencies->getKind());
|
|
}
|
|
}
|
|
|
|
return llvm::None;
|
|
}
|