[clang-tools-extra] r229869 - Added module map coverage support, extracted from module-map-checker.
John Thompson
John.Thompson.JTSoftware at gmail.com
Thu Feb 19 08:47:27 PST 2015
Author: jtsoftware
Date: Thu Feb 19 10:47:27 2015
New Revision: 229869
URL: http://llvm.org/viewvc/llvm-project?rev=229869&view=rev
Log:
Added module map coverage support, extracted from module-map-checker.
Added:
clang-tools-extra/trunk/modularize/CoverageChecker.cpp
clang-tools-extra/trunk/modularize/CoverageChecker.h
clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/
clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/Includes1/
clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/Includes1/Level1A.h
clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/Includes2/
clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/Includes2/Level2A.h
clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/NonIncludes/
clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/NonIncludes/Level3A.h
clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/module.modulemap
clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/
clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level1A.h
clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level1B.h
clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level2A.h
clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level2B.h
clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level3A.h
clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Sub/
clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Sub/Level3B.h
clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaFile.h
clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaInclude1.h
clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaInclude2.h
clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaSub/
clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaSub/Umbrell1.h
clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaSub/Umbrell2.h
clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/module.modulemap
clang-tools-extra/trunk/test/modularize/NoProblemsCoverage.modularize
clang-tools-extra/trunk/test/modularize/ProblemsCoverage.modularize
Modified:
clang-tools-extra/trunk/docs/ModularizeUsage.rst
clang-tools-extra/trunk/docs/modularize.rst
clang-tools-extra/trunk/modularize/CMakeLists.txt
clang-tools-extra/trunk/modularize/Modularize.cpp
clang-tools-extra/trunk/modularize/ModularizeUtilities.cpp
clang-tools-extra/trunk/modularize/ModularizeUtilities.h
clang-tools-extra/trunk/test/modularize/NoProblems.modularize
Modified: clang-tools-extra/trunk/docs/ModularizeUsage.rst
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/docs/ModularizeUsage.rst?rev=229869&r1=229868&r2=229869&view=diff
==============================================================================
--- clang-tools-extra/trunk/docs/ModularizeUsage.rst (original)
+++ clang-tools-extra/trunk/docs/ModularizeUsage.rst Thu Feb 19 10:47:27 2015
@@ -41,6 +41,10 @@ Note that by default, the underlying Cla
contain C source, so you might need to specify the ``-x c++`` Clang option
to tell Clang that the header contains C++ definitions.
+Note also that because modularize does not use the clang driver,
+you will likely need to pass in additional compiler front-end
+arguments to match those passed in by default by the driver.
+
Modularize Command Line Options
===============================
@@ -66,3 +70,11 @@ Modularize Command Line Options
check to only those headers explicitly listed in the header list.
This is a work-around for avoiding error messages for private includes that
purposefully get included inside blocks.
+
+.. option:: -no-coverage-check
+
+ Don't do the coverage check for a module map.
+
+.. option:: -coverage-check-only
+
+ Only do the coverage check for a module map.
Modified: clang-tools-extra/trunk/docs/modularize.rst
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/docs/modularize.rst?rev=229869&r1=229868&r2=229869&view=diff
==============================================================================
--- clang-tools-extra/trunk/docs/modularize.rst (original)
+++ clang-tools-extra/trunk/docs/modularize.rst Thu Feb 19 10:47:27 2015
@@ -56,6 +56,8 @@ Modularize will check for the following:
* Macro instances, 'defined(macro)', or #if, #elif, #ifdef, #ifndef conditions
that evaluate differently in a header
* #include directives inside 'extern "C/C++" {}' or 'namespace (name) {}' blocks
+* Module map header coverage completeness (in the case of a module map input
+ only)
Modularize will do normal C/C++ parsing, reporting normal errors and warnings,
but will also report special error messages like the following::
@@ -107,6 +109,44 @@ and can produce error message like the f
^
The "extern "C" {}" block is here.
+.. _module-map-coverage:
+
+Module Map Coverage Check
+=========================
+
+The coverage check uses the Clang library to read and parse the
+module map file. Starting at the module map file directory, or just the
+include paths, if specified, it will collect the names of all the files it
+considers headers (no extension, .h, or .inc--if you need more, modify the
+isHeader function). It then compares the headers against those referenced
+in the module map, either explicitly named, or implicitly named via an
+umbrella directory or umbrella file, as parsed by the ModuleMap object.
+If headers are found which are not referenced or covered by an umbrella
+directory or file, warning messages will be produced, and this program
+will return an error code of 1. If no problems are found, an error code of
+0 is returned.
+
+Note that in the case of umbrella headers, this tool invokes the compiler
+to preprocess the file, and uses a callback to collect the header files
+included by the umbrella header or any of its nested includes. If any
+front end options are needed for these compiler invocations, these
+can be included on the command line after the module map file argument.
+
+Warning message have the form:
+
+ warning: module.modulemap does not account for file: Level3A.h
+
+Note that for the case of the module map referencing a file that does
+not exist, the module map parser in Clang will (at the time of this
+writing) display an error message.
+
+To limit the checks :program:`modularize` does to just the module
+map coverage check, use the ``-coverage-check-only option``.
+
+For example::
+
+ modularize -coverage-check-only module.modulemap
+
.. _module-map-generation:
Module Map Generation
Modified: clang-tools-extra/trunk/modularize/CMakeLists.txt
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/modularize/CMakeLists.txt?rev=229869&r1=229868&r2=229869&view=diff
==============================================================================
--- clang-tools-extra/trunk/modularize/CMakeLists.txt (original)
+++ clang-tools-extra/trunk/modularize/CMakeLists.txt Thu Feb 19 10:47:27 2015
@@ -7,6 +7,7 @@ add_clang_executable(modularize
Modularize.cpp
ModuleAssistant.cpp
ModularizeUtilities.cpp
+ CoverageChecker.cpp
PreprocessorTracker.cpp
)
Added: clang-tools-extra/trunk/modularize/CoverageChecker.cpp
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/modularize/CoverageChecker.cpp?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/modularize/CoverageChecker.cpp (added)
+++ clang-tools-extra/trunk/modularize/CoverageChecker.cpp Thu Feb 19 10:47:27 2015
@@ -0,0 +1,415 @@
+//===--- extra/module-map-checker/CoverageChecker.cpp -------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements a class that validates a module map by checking that
+// all headers in the corresponding directories are accounted for.
+//
+// This class uses a previously loaded module map object.
+// Starting at the module map file directory, or just the include
+// paths, if specified, it will collect the names of all the files it
+// considers headers (no extension, .h, or .inc--if you need more, modify the
+// ModularizeUtilities::isHeader function).
+// It then compares the headers against those referenced
+// in the module map, either explicitly named, or implicitly named via an
+// umbrella directory or umbrella file, as parsed by the ModuleMap object.
+// If headers are found which are not referenced or covered by an umbrella
+// directory or file, warning messages will be produced, and the doChecks
+// function will return an error code of 1. Other errors result in an error
+// code of 2. If no problems are found, an error code of 0 is returned.
+//
+// Note that in the case of umbrella headers, this tool invokes the compiler
+// to preprocess the file, and uses a callback to collect the header files
+// included by the umbrella header or any of its nested includes. If any
+// front end options are needed for these compiler invocations, these are
+// to be passed in via the CommandLine parameter.
+//
+// Warning message have the form:
+//
+// warning: module.modulemap does not account for file: Level3A.h
+//
+// Note that for the case of the module map referencing a file that does
+// not exist, the module map parser in Clang will (at the time of this
+// writing) display an error message.
+//
+// Potential problems with this program:
+//
+// 1. Might need a better header matching mechanism, or extensions to the
+// canonical file format used.
+//
+// 2. It might need to support additional header file extensions.
+//
+// Future directions:
+//
+// 1. Add an option to fix the problems found, writing a new module map.
+// Include an extra option to add unaccounted-for headers as excluded.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ModularizeUtilities.h"
+#include "clang/AST/ASTConsumer.h"
+#include "CoverageChecker.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Driver/Options.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Frontend/FrontendActions.h"
+#include "clang/Lex/PPCallbacks.h"
+#include "clang/Lex/Preprocessor.h"
+#include "clang/Tooling/CompilationDatabase.h"
+#include "clang/Tooling/Tooling.h"
+#include "llvm/Option/Option.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace Modularize;
+using namespace clang;
+using namespace clang::driver;
+using namespace clang::driver::options;
+using namespace clang::tooling;
+namespace cl = llvm::cl;
+namespace sys = llvm::sys;
+
+// Preprocessor callbacks.
+// We basically just collect include files.
+class CoverageCheckerCallbacks : public PPCallbacks {
+public:
+ CoverageCheckerCallbacks(CoverageChecker &Checker) : Checker(Checker) {}
+ ~CoverageCheckerCallbacks() {}
+
+ // Include directive callback.
+ void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
+ StringRef FileName, bool IsAngled,
+ CharSourceRange FilenameRange, const FileEntry *File,
+ StringRef SearchPath, StringRef RelativePath,
+ const Module *Imported) {
+ Checker.collectUmbrellaHeaderHeader(File->getName());
+ }
+
+private:
+ CoverageChecker &Checker;
+};
+
+// Frontend action stuff:
+
+// Consumer is responsible for setting up the callbacks.
+class CoverageCheckerConsumer : public ASTConsumer {
+public:
+ CoverageCheckerConsumer(CoverageChecker &Checker, Preprocessor &PP) {
+ // PP takes ownership.
+ PP.addPPCallbacks(llvm::make_unique<CoverageCheckerCallbacks>(Checker));
+ }
+};
+
+class CoverageCheckerAction : public SyntaxOnlyAction {
+public:
+ CoverageCheckerAction(CoverageChecker &Checker) : Checker(Checker) {}
+
+protected:
+ std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
+ StringRef InFile) override {
+ return llvm::make_unique<CoverageCheckerConsumer>(Checker,
+ CI.getPreprocessor());
+ }
+
+private:
+ CoverageChecker &Checker;
+};
+
+class CoverageCheckerFrontendActionFactory : public FrontendActionFactory {
+public:
+ CoverageCheckerFrontendActionFactory(CoverageChecker &Checker)
+ : Checker(Checker) {}
+
+ virtual CoverageCheckerAction *create() {
+ return new CoverageCheckerAction(Checker);
+ }
+
+private:
+ CoverageChecker &Checker;
+};
+
+// CoverageChecker class implementation.
+
+// Constructor.
+CoverageChecker::CoverageChecker(StringRef ModuleMapPath,
+ std::vector<std::string> &IncludePaths,
+ ArrayRef<std::string> CommandLine,
+ clang::ModuleMap *ModuleMap)
+ : ModuleMapPath(ModuleMapPath), IncludePaths(IncludePaths),
+ CommandLine(CommandLine),
+ ModMap(ModuleMap) {}
+
+// Create instance of CoverageChecker, to simplify setting up
+// subordinate objects.
+CoverageChecker *CoverageChecker::createCoverageChecker(
+ StringRef ModuleMapPath, std::vector<std::string> &IncludePaths,
+ ArrayRef<std::string> CommandLine, clang::ModuleMap *ModuleMap) {
+
+ return new CoverageChecker(ModuleMapPath, IncludePaths, CommandLine,
+ ModuleMap);
+}
+
+// Do checks.
+// Starting from the directory of the module.modulemap file,
+// Find all header files, optionally looking only at files
+// covered by the include path options, and compare against
+// the headers referenced by the module.modulemap file.
+// Display warnings for unaccounted-for header files.
+// Returns error_code of 0 if there were no errors or warnings, 1 if there
+// were warnings, 2 if any other problem, such as if a bad
+// module map path argument was specified.
+std::error_code CoverageChecker::doChecks() {
+ std::error_code returnValue;
+
+ // Collect the headers referenced in the modules.
+ collectModuleHeaders();
+
+ // Collect the file system headers.
+ if (!collectFileSystemHeaders())
+ return std::error_code(2, std::generic_category());
+
+ // Do the checks. These save the problematic file names.
+ findUnaccountedForHeaders();
+
+ // Check for warnings.
+ if (!UnaccountedForHeaders.empty())
+ returnValue = std::error_code(1, std::generic_category());
+
+ return returnValue;
+}
+
+// The following functions are called by doChecks.
+
+// Collect module headers.
+// Walks the modules and collects referenced headers into
+// ModuleMapHeadersSet.
+void CoverageChecker::collectModuleHeaders() {
+ for (ModuleMap::module_iterator I = ModMap->module_begin(),
+ E = ModMap->module_end();
+ I != E; ++I) {
+ collectModuleHeaders(*I->second);
+ }
+}
+
+// Collect referenced headers from one module.
+// Collects the headers referenced in the given module into
+// ModuleMapHeadersSet.
+// FIXME: Doesn't collect files from umbrella header.
+bool CoverageChecker::collectModuleHeaders(const Module &Mod) {
+
+ if (const FileEntry *UmbrellaHeader = Mod.getUmbrellaHeader()) {
+ // Collect umbrella header.
+ ModuleMapHeadersSet.insert(ModularizeUtilities::getCanonicalPath(
+ UmbrellaHeader->getName()));
+ // Preprocess umbrella header and collect the headers it references.
+ if (!collectUmbrellaHeaderHeaders(UmbrellaHeader->getName()))
+ return false;
+ }
+ else if (const DirectoryEntry *UmbrellaDir = Mod.getUmbrellaDir()) {
+ // Collect headers in umbrella directory.
+ if (!collectUmbrellaHeaders(UmbrellaDir->getName()))
+ return false;
+ }
+
+ for (auto &HeaderKind : Mod.Headers)
+ for (auto &Header : HeaderKind)
+ ModuleMapHeadersSet.insert(ModularizeUtilities::getCanonicalPath(
+ Header.Entry->getName()));
+
+ for (Module::submodule_const_iterator MI = Mod.submodule_begin(),
+ MIEnd = Mod.submodule_end();
+ MI != MIEnd; ++MI)
+ collectModuleHeaders(**MI);
+
+ return true;
+}
+
+// Collect headers from an umbrella directory.
+bool CoverageChecker::collectUmbrellaHeaders(StringRef UmbrellaDirName) {
+ // Initialize directory name.
+ SmallString<256> Directory(ModuleMapDirectory);
+ if (UmbrellaDirName.size())
+ sys::path::append(Directory, UmbrellaDirName);
+ if (Directory.size() == 0)
+ Directory = ".";
+ // Walk the directory.
+ std::error_code EC;
+ sys::fs::file_status Status;
+ for (sys::fs::directory_iterator I(Directory.str(), EC), E; I != E;
+ I.increment(EC)) {
+ if (EC)
+ return false;
+ std::string File(I->path());
+ I->status(Status);
+ sys::fs::file_type Type = Status.type();
+ // If the file is a directory, ignore the name and recurse.
+ if (Type == sys::fs::file_type::directory_file) {
+ if (!collectUmbrellaHeaders(File))
+ return false;
+ continue;
+ }
+ // If the file does not have a common header extension, ignore it.
+ if (!ModularizeUtilities::isHeader(File))
+ continue;
+ // Save header name.
+ ModuleMapHeadersSet.insert(ModularizeUtilities::getCanonicalPath(File));
+ }
+ return true;
+}
+
+// Collect headers rferenced from an umbrella file.
+bool
+CoverageChecker::collectUmbrellaHeaderHeaders(StringRef UmbrellaHeaderName) {
+
+ SmallString<256> PathBuf(ModuleMapDirectory);
+
+ // If directory is empty, it's the current directory.
+ if (ModuleMapDirectory.length() == 0)
+ sys::fs::current_path(PathBuf);
+
+ // Create the compilation database.
+ std::unique_ptr<CompilationDatabase> Compilations;
+ Compilations.reset(new FixedCompilationDatabase(Twine(PathBuf), CommandLine));
+
+ std::vector<std::string> HeaderPath;
+ HeaderPath.push_back(UmbrellaHeaderName);
+
+ // Create the tool and run the compilation.
+ ClangTool Tool(*Compilations, HeaderPath);
+ int HadErrors = Tool.run(new CoverageCheckerFrontendActionFactory(*this));
+
+ // If we had errors, exit early.
+ return HadErrors ? false : true;
+}
+
+// Called from CoverageCheckerCallbacks to track a header included
+// from an umbrella header.
+void CoverageChecker::collectUmbrellaHeaderHeader(StringRef HeaderName) {
+
+ SmallString<256> PathBuf(ModuleMapDirectory);
+ // If directory is empty, it's the current directory.
+ if (ModuleMapDirectory.length() == 0)
+ sys::fs::current_path(PathBuf);
+ // HeaderName will have an absolute path, so if it's the module map
+ // directory, we remove it, also skipping trailing separator.
+ if (HeaderName.startswith(PathBuf))
+ HeaderName = HeaderName.substr(PathBuf.size() + 1);
+ // Save header name.
+ ModuleMapHeadersSet.insert(ModularizeUtilities::getCanonicalPath(HeaderName));
+}
+
+// Collect file system header files.
+// This function scans the file system for header files,
+// starting at the directory of the module.modulemap file,
+// optionally filtering out all but the files covered by
+// the include path options.
+// Returns true if no errors.
+bool CoverageChecker::collectFileSystemHeaders() {
+
+ // Get directory containing the module.modulemap file.
+ // Might be relative to current directory, absolute, or empty.
+ ModuleMapDirectory = ModularizeUtilities::getDirectoryFromPath(ModuleMapPath);
+
+ // If no include paths specified, we do the whole tree starting
+ // at the module.modulemap directory.
+ if (IncludePaths.size() == 0) {
+ if (!collectFileSystemHeaders(StringRef("")))
+ return false;
+ }
+ else {
+ // Otherwise we only look at the sub-trees specified by the
+ // include paths.
+ for (std::vector<std::string>::const_iterator I = IncludePaths.begin(),
+ E = IncludePaths.end();
+ I != E; ++I) {
+ if (!collectFileSystemHeaders(*I))
+ return false;
+ }
+ }
+
+ // Sort it, because different file systems might order the file differently.
+ std::sort(FileSystemHeaders.begin(), FileSystemHeaders.end());
+
+ return true;
+}
+
+// Collect file system header files from the given path.
+// This function scans the file system for header files,
+// starting at the given directory, which is assumed to be
+// relative to the directory of the module.modulemap file.
+// \returns True if no errors.
+bool CoverageChecker::collectFileSystemHeaders(StringRef IncludePath) {
+
+ // Initialize directory name.
+ SmallString<256> Directory(ModuleMapDirectory);
+ if (IncludePath.size())
+ sys::path::append(Directory, IncludePath);
+ if (Directory.size() == 0)
+ Directory = ".";
+ if (IncludePath.startswith("/") || IncludePath.startswith("\\") ||
+ ((IncludePath.size() >= 2) && (IncludePath[1] == ':'))) {
+ llvm::errs() << "error: Include path \"" << IncludePath
+ << "\" is not relative to the module map file.\n";
+ return false;
+ }
+
+ // Recursively walk the directory tree.
+ std::error_code EC;
+ sys::fs::file_status Status;
+ int Count = 0;
+ for (sys::fs::recursive_directory_iterator I(Directory.str(), EC), E; I != E;
+ I.increment(EC)) {
+ if (EC)
+ return false;
+ std::string file(I->path());
+ I->status(Status);
+ sys::fs::file_type type = Status.type();
+ // If the file is a directory, ignore the name (but still recurses).
+ if (type == sys::fs::file_type::directory_file)
+ continue;
+ // If the file does not have a common header extension, ignore it.
+ if (!ModularizeUtilities::isHeader(file))
+ continue;
+ // Save header name.
+ FileSystemHeaders.push_back(ModularizeUtilities::getCanonicalPath(file));
+ Count++;
+ }
+ if (Count == 0) {
+ llvm::errs() << "warning: No headers found in include path: \""
+ << IncludePath << "\"\n";
+ }
+ return true;
+}
+
+// Find headers unaccounted-for in module map.
+// This function compares the list of collected header files
+// against those referenced in the module map. Display
+// warnings for unaccounted-for header files.
+// Save unaccounted-for file list for possible.
+// fixing action.
+// FIXME: There probably needs to be some canonalization
+// of file names so that header path can be correctly
+// matched. Also, a map could be used for the headers
+// referenced in the module, but
+void CoverageChecker::findUnaccountedForHeaders() {
+ // Walk over file system headers.
+ for (std::vector<std::string>::const_iterator I = FileSystemHeaders.begin(),
+ E = FileSystemHeaders.end();
+ I != E; ++I) {
+ // Look for header in module map.
+ if (ModuleMapHeadersSet.insert(*I).second) {
+ UnaccountedForHeaders.push_back(*I);
+ llvm::errs() << "warning: " << ModuleMapPath
+ << " does not account for file: " << *I << "\n";
+ }
+ }
+}
Added: clang-tools-extra/trunk/modularize/CoverageChecker.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/modularize/CoverageChecker.h?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/modularize/CoverageChecker.h (added)
+++ clang-tools-extra/trunk/modularize/CoverageChecker.h Thu Feb 19 10:47:27 2015
@@ -0,0 +1,172 @@
+//===-- CoverageChecker.h - Module map coverage checker -*- C++ -*-------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===--------------------------------------------------------------------===//
+///
+/// \file
+/// \brief Definitions for CoverageChecker.
+///
+//===--------------------------------------------------------------------===//
+
+#ifndef COVERAGECHECKER_H
+#define COVERAGECHECKER_H
+
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/FileManager.h"
+#include "clang/Basic/LangOptions.h"
+#include "clang/Basic/TargetInfo.h"
+#include "clang/Basic/TargetOptions.h"
+#include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "clang/Lex/HeaderSearch.h"
+#include "clang/Lex/HeaderSearchOptions.h"
+#include "clang/Lex/ModuleMap.h"
+#include "clang/Lex/Preprocessor.h"
+#include "llvm/ADT/StringSet.h"
+#include "llvm/Support/Host.h"
+#include <string>
+#include <vector>
+
+namespace Modularize {
+
+/// Subclass TargetOptions so we can construct it inline with
+/// the minimal option, the triple.
+class ModuleMapTargetOptions : public clang::TargetOptions {
+public:
+ ModuleMapTargetOptions() { Triple = llvm::sys::getDefaultTargetTriple(); }
+};
+
+/// Module map checker class.
+/// This is the heart of the checker.
+/// The doChecks function does the main work.
+/// The data members store the options and internally collected data.
+class CoverageChecker {
+ // Checker arguments.
+
+ /// The module.modulemap file path. Can be relative or absolute.
+ llvm::StringRef ModuleMapPath;
+ /// The include paths to check for files.
+ /// (Note that other directories above these paths are ignored.
+ /// To expect all files to be accounted for from the module.modulemap
+ /// file directory on down, leave this empty.)
+ std::vector<std::string> IncludePaths;
+ /// The remaining arguments, to be passed to the front end.
+ llvm::ArrayRef<std::string> CommandLine;
+ /// The module map.
+ clang::ModuleMap *ModMap;
+
+ // Internal data.
+
+ /// Directory containing the module map.
+ /// Might be relative to the current directory, or absolute.
+ std::string ModuleMapDirectory;
+ /// Set of all the headers found in the module map.
+ llvm::StringSet<llvm::MallocAllocator> ModuleMapHeadersSet;
+ /// All the headers found in the file system starting at the
+ /// module map, or the union of those from the include paths.
+ std::vector<std::string> FileSystemHeaders;
+ /// Headers found in file system, but not in module map.
+ std::vector<std::string> UnaccountedForHeaders;
+
+public:
+ /// Constructor.
+ /// You can use the static createCoverageChecker to create an instance
+ /// of this object.
+ /// \param ModuleMapPath The module.modulemap file path.
+ /// Can be relative or absolute.
+ /// \param IncludePaths The include paths to check for files.
+ /// (Note that other directories above these paths are ignored.
+ /// To expect all files to be accounted for from the module.modulemap
+ /// file directory on down, leave this empty.)
+ /// \param CommandLine Compile command line arguments.
+ /// \param ModuleMap The module map to check.
+ CoverageChecker(llvm::StringRef ModuleMapPath,
+ std::vector<std::string> &IncludePaths,
+ llvm::ArrayRef<std::string> CommandLine,
+ clang::ModuleMap *ModuleMap);
+
+ /// Create instance of CoverageChecker.
+ /// \param ModuleMapPath The module.modulemap file path.
+ /// Can be relative or absolute.
+ /// \param IncludePaths The include paths to check for files.
+ /// (Note that other directories above these paths are ignored.
+ /// To expect all files to be accounted for from the module.modulemap
+ /// file directory on down, leave this empty.)
+ /// \param CommandLine Compile command line arguments.
+ /// \param ModuleMap The module map to check.
+ /// \returns Initialized CoverageChecker object.
+ static CoverageChecker *createCoverageChecker(
+ llvm::StringRef ModuleMapPath, std::vector<std::string> &IncludePaths,
+ llvm::ArrayRef<std::string> CommandLine,
+ clang::ModuleMap *ModuleMap);
+
+ /// Do checks.
+ /// Starting from the directory of the module.modulemap file,
+ /// Find all header files, optionally looking only at files
+ /// covered by the include path options, and compare against
+ /// the headers referenced by the module.modulemap file.
+ /// Display warnings for unaccounted-for header files.
+ /// \returns 0 if there were no errors or warnings, 1 if there
+ /// were warnings, 2 if any other problem, such as a bad
+ /// module map path argument was specified.
+ std::error_code doChecks();
+
+ // The following functions are called by doChecks.
+
+ /// Collect module headers.
+ /// Walks the modules and collects referenced headers into
+ /// ModuleMapHeadersSet.
+ void collectModuleHeaders();
+
+ /// Collect referenced headers from one module.
+ /// Collects the headers referenced in the given module into
+ /// ModuleMapHeadersSet.
+ /// \param Mod The module reference.
+ /// \return True if no errors.
+ bool collectModuleHeaders(const clang::Module &Mod);
+
+ /// Collect headers from an umbrella directory.
+ /// \param UmbrellaDirName The umbrella directory name.
+ /// \return True if no errors.
+ bool collectUmbrellaHeaders(llvm::StringRef UmbrellaDirName);
+
+ /// Collect headers rferenced from an umbrella file.
+ /// \param UmbrellaHeaderName The umbrella file path.
+ /// \return True if no errors.
+ bool collectUmbrellaHeaderHeaders(llvm::StringRef UmbrellaHeaderName);
+
+ /// Called from CoverageCheckerCallbacks to track a header included
+ /// from an umbrella header.
+ /// \param HeaderName The header file path.
+ void collectUmbrellaHeaderHeader(llvm::StringRef HeaderName);
+
+ /// Collect file system header files.
+ /// This function scans the file system for header files,
+ /// starting at the directory of the module.modulemap file,
+ /// optionally filtering out all but the files covered by
+ /// the include path options.
+ /// \returns True if no errors.
+ bool collectFileSystemHeaders();
+
+ /// Collect file system header files from the given path.
+ /// This function scans the file system for header files,
+ /// starting at the given directory, which is assumed to be
+ /// relative to the directory of the module.modulemap file.
+ /// \returns True if no errors.
+ bool collectFileSystemHeaders(llvm::StringRef IncludePath);
+
+ /// Find headers unaccounted-for in module map.
+ /// This function compares the list of collected header files
+ /// against those referenced in the module map. Display
+ /// warnings for unaccounted-for header files.
+ /// Save unaccounted-for file list for possible.
+ /// fixing action.
+ void findUnaccountedForHeaders();
+};
+
+} // end namespace Modularize
+
+#endif // COVERAGECHECKER_H
Modified: clang-tools-extra/trunk/modularize/Modularize.cpp
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/modularize/Modularize.cpp?rev=229869&r1=229868&r2=229869&view=diff
==============================================================================
--- clang-tools-extra/trunk/modularize/Modularize.cpp (original)
+++ clang-tools-extra/trunk/modularize/Modularize.cpp Thu Feb 19 10:47:27 2015
@@ -7,6 +7,8 @@
//
//===----------------------------------------------------------------------===//
//
+// Introduction
+//
// This file implements a tool that checks whether a set of headers provides
// the consistent definitions required to use modules. It can also check an
// existing module map for full coverage of the headers in a directory tree.
@@ -62,17 +64,23 @@
// -block-check-header-list-only
// Only warn if #include directives are inside extern or namespace
// blocks if the included header is in the header list.
-//
-// Note that unless a "-prefix (header path)" option is specified,
-// non-absolute file paths in the header list file will be relative
-// to the header list file directory. Use -prefix to specify a different
-// directory.
+// -no-coverage-check
+// Don't do the coverage check.
+// -coverage-check-only
+// Only do the coverage check.
+//
+// Note that because modularize does not use the clang driver,
+// you will likely need to pass in additional compiler front-end
+// arguments to match those passed in by default by the driver.
//
// Note that by default, the underlying Clang front end assumes .h files
// contain C source. If your .h files in the file list contain C++ source,
// you should append the following to your command lines: -x c++
//
-// Modularize will do normal parsing, reporting normal errors and warnings,
+// Modularization Issue Checks
+//
+// In the process of checking headers for modularization issues, modularize
+// will do normal parsing, reporting normal errors and warnings,
// but will also report special error messages like the following:
//
// error: '(symbol)' defined at multiple locations:
@@ -125,6 +133,36 @@
//
// See PreprocessorTracker.cpp for additional details.
//
+// Module Map Coverage Check
+//
+// The coverage check uses the Clang ModuleMap class to read and parse the
+// module map file. Starting at the module map file directory, or just the
+// include paths, if specified, it will collect the names of all the files it
+// considers headers (no extension, .h, or .inc--if you need more, modify the
+// isHeader function). It then compares the headers against those referenced
+// in the module map, either explicitly named, or implicitly named via an
+// umbrella directory or umbrella file, as parsed by the ModuleMap object.
+// If headers are found which are not referenced or covered by an umbrella
+// directory or file, warning messages will be produced, and this program
+// will return an error code of 1. Other errors result in an error code of 2.
+// If no problems are found, an error code of 0 is returned.
+//
+// Note that in the case of umbrella headers, this tool invokes the compiler
+// to preprocess the file, and uses a callback to collect the header files
+// included by the umbrella header or any of its nested includes. If any
+// front end options are needed for these compiler invocations, these
+// can be included on the command line after the module map file argument.
+//
+// Warning message have the form:
+//
+// warning: module.modulemap does not account for file: Level3A.h
+//
+// Note that for the case of the module map referencing a file that does
+// not exist, the module map parser in Clang will (at the time of this
+// writing) display an error message.
+//
+// Module Map Assistant - Module Map Generation
+//
// Modularize also has an option ("-module-map-path=module.modulemap") that will
// skip the checks, and instead act as a module.modulemap generation assistant,
// generating a module map file based on the header list. An optional
@@ -255,6 +293,21 @@ BlockCheckHeaderListOnly("block-check-he
cl::desc("Only warn if #include directives are inside extern or namespace"
" blocks if the included header is in the header list."));
+// Option for include paths for coverage check.
+static cl::list<std::string>
+IncludePaths("I", cl::desc("Include path for coverage check."),
+cl::ZeroOrMore, cl::value_desc("path"));
+
+// Option for just doing the coverage check.
+static cl::opt<bool>
+NoCoverageCheck("no-coverage-check", cl::init(false),
+cl::desc("Don't do the coverage check."));
+
+// Option for just doing the coverage check.
+static cl::opt<bool>
+CoverageCheckOnly("coverage-check-only", cl::init(false),
+cl::desc("Only do the coverage check."));
+
// Save the program name for error messages.
const char *Argv0;
// Save the command line for comments.
@@ -669,7 +722,8 @@ int main(int Argc, const char **Argv) {
}
std::unique_ptr<ModularizeUtilities> ModUtil;
-
+ int HadErrors = 0;
+
ModUtil.reset(
ModularizeUtilities::createModularizeUtilities(
ListFileNames, HeaderPrefix));
@@ -686,6 +740,17 @@ int main(int Argc, const char **Argv) {
return 0; // Success - Skip checks in assistant mode.
}
+ // If we're doing module maps.
+ if (!NoCoverageCheck && ModUtil->HasModuleMap) {
+ // Do coverage check.
+ if (ModUtil->doCoverageCheck(IncludePaths, CommandLine))
+ HadErrors = 1;
+ }
+
+ // Bail early if only doing the coverage check.
+ if (CoverageCheckOnly)
+ return HadErrors;
+
// Create the compilation database.
SmallString<256> PathBuf;
sys::fs::current_path(PathBuf);
@@ -702,7 +767,6 @@ int main(int Argc, const char **Argv) {
EntityMap Entities;
ClangTool Tool(*Compilations, ModUtil->HeaderFileNames);
Tool.appendArgumentsAdjuster(getAddDependenciesAdjuster(ModUtil->Dependencies));
- int HadErrors = 0;
ModularizeFrontendActionFactory Factory(Entities, *PPTracker, HadErrors);
HadErrors |= Tool.run(&Factory);
@@ -737,7 +801,7 @@ int main(int Argc, const char **Argv) {
for (EntryBinArray::iterator DI = EntryBins.begin(), DE = EntryBins.end();
DI != DE; ++DI, ++KindIndex) {
int ECount = DI->size();
- // If only 1 occurrence of this entity, skip it, as we only report duplicates.
+ // If only 1 occurrence of this entity, skip it, we only report duplicates.
if (ECount <= 1)
continue;
LocationArray::iterator FI = DI->begin();
Modified: clang-tools-extra/trunk/modularize/ModularizeUtilities.cpp
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/modularize/ModularizeUtilities.cpp?rev=229869&r1=229868&r2=229869&view=diff
==============================================================================
--- clang-tools-extra/trunk/modularize/ModularizeUtilities.cpp (original)
+++ clang-tools-extra/trunk/modularize/ModularizeUtilities.cpp Thu Feb 19 10:47:27 2015
@@ -13,16 +13,17 @@
//
//===----------------------------------------------------------------------===//
-#include "ModularizeUtilities.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Driver/Options.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/FrontendActions.h"
+#include "CoverageChecker.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/Support/FileUtilities.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/raw_ostream.h"
+#include "ModularizeUtilities.h"
using namespace clang;
using namespace llvm;
@@ -42,6 +43,7 @@ ModularizeUtilities::ModularizeUtilities
llvm::StringRef Prefix)
: InputFilePaths(InputPaths),
HeaderPrefix(Prefix),
+ HasModuleMap(false),
// Init clang stuff needed for loading the module map and preprocessing.
LangOpts(new LangOptions()), DiagIDs(new DiagnosticIDs()),
DiagnosticOpts(new DiagnosticOptions()),
@@ -88,7 +90,34 @@ std::error_code ModularizeUtilities::loa
}
return std::error_code();
}
-
+
+// Do coverage checks.
+// For each loaded module map, do header coverage check.
+// Starting from the directory of the module.map file,
+// Find all header files, optionally looking only at files
+// covered by the include path options, and compare against
+// the headers referenced by the module.map file.
+// Display warnings for unaccounted-for header files.
+// Returns 0 if there were no errors or warnings, 1 if there
+// were warnings, 2 if any other problem, such as a bad
+// module map path argument was specified.
+std::error_code ModularizeUtilities::doCoverageCheck(
+ std::vector<std::string> &IncludePaths,
+ llvm::ArrayRef<std::string> CommandLine) {
+ int ModuleMapCount = ModuleMaps.size();
+ int ModuleMapIndex;
+ std::error_code EC;
+ for (ModuleMapIndex = 0; ModuleMapIndex < ModuleMapCount; ++ModuleMapIndex) {
+ std::unique_ptr<clang::ModuleMap> &ModMap = ModuleMaps[ModuleMapIndex];
+ CoverageChecker *Checker = CoverageChecker::createCoverageChecker(
+ InputFilePaths[ModuleMapIndex], IncludePaths, CommandLine, ModMap.get());
+ std::error_code LocalEC = Checker->doChecks();
+ if (LocalEC.value() > 0)
+ EC = LocalEC;
+ }
+ return EC;
+}
+
// Load single header list and dependencies.
std::error_code ModularizeUtilities::loadSingleHeaderListsAndDependencies(
llvm::StringRef InputPath) {
@@ -209,6 +238,9 @@ std::error_code ModularizeUtilities::loa
// Save module map.
ModuleMaps.push_back(std::move(ModMap));
+ // Indicate we are using module maps.
+ HasModuleMap = true;
+
return std::error_code();
}
@@ -338,3 +370,16 @@ bool ModularizeUtilities::isHeader(Strin
return true;
return false;
}
+
+// Get directory path component from file path.
+// \returns the component of the given path, which will be
+// relative if the given path is relative, absolute if the
+// given path is absolute, or "." if the path has no leading
+// path component.
+std::string ModularizeUtilities::getDirectoryFromPath(StringRef Path) {
+ SmallString<256> Directory(Path);
+ sys::path::remove_filename(Directory);
+ if (Directory.size() == 0)
+ return ".";
+ return Directory.str();
+}
Modified: clang-tools-extra/trunk/modularize/ModularizeUtilities.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/modularize/ModularizeUtilities.h?rev=229869&r1=229868&r2=229869&view=diff
==============================================================================
--- clang-tools-extra/trunk/modularize/ModularizeUtilities.h (original)
+++ clang-tools-extra/trunk/modularize/ModularizeUtilities.h Thu Feb 19 10:47:27 2015
@@ -50,6 +50,8 @@ public:
llvm::SmallVector<std::string, 32> HeaderFileNames;
/// Map of top-level header file dependencies.
DependencyMap Dependencies;
+ /// True if we have module maps.
+ bool HasModuleMap;
// Functions.
@@ -67,12 +69,30 @@ public:
/// \returns Initialized ModularizeUtilities object.
static ModularizeUtilities *createModularizeUtilities(
std::vector<std::string> &InputPaths,
- llvm::StringRef Prefix);
+ llvm::StringRef Prefix);
/// Load header list and dependencies.
/// \returns std::error_code.
std::error_code loadAllHeaderListsAndDependencies();
+ /// Do coverage checks.
+ /// For each loaded module map, do header coverage check.
+ /// Starting from the directory of the module.map file,
+ /// Find all header files, optionally looking only at files
+ /// covered by the include path options, and compare against
+ /// the headers referenced by the module.map file.
+ /// Display warnings for unaccounted-for header files.
+ /// \param IncludePaths The include paths to check for files.
+ /// (Note that other directories above these paths are ignored.
+ /// To expect all files to be accounted for from the module.modulemap
+ /// file directory on down, leave this empty.)
+ /// \param CommandLine Compile command line arguments.
+ /// \returns 0 if there were no errors or warnings, 1 if there
+ /// were warnings, 2 if any other problem, such as a bad
+ /// module map path argument was specified.
+ std::error_code doCoverageCheck(std::vector<std::string> &IncludePaths,
+ llvm::ArrayRef<std::string> CommandLine);
+
// Internal.
protected:
@@ -127,6 +147,13 @@ public:
/// \returns true if it has a header extension or no extension.
static bool isHeader(llvm::StringRef FileName);
+ /// Get directory path component from file path.
+ /// \returns the component of the given path, which will be
+ /// relative if the given path is relative, absolute if the
+ /// given path is absolute, or "." if the path has no leading
+ /// path component.
+ static std::string getDirectoryFromPath(llvm::StringRef Path);
+
// Internal data.
/// Options controlling the language variant.
Added: clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/Includes1/Level1A.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/Includes1/Level1A.h?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/Includes1/Level1A.h (added)
+++ clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/Includes1/Level1A.h Thu Feb 19 10:47:27 2015
@@ -0,0 +1 @@
+#define MACRO_1A 1
Added: clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/Includes2/Level2A.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/Includes2/Level2A.h?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/Includes2/Level2A.h (added)
+++ clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/Includes2/Level2A.h Thu Feb 19 10:47:27 2015
@@ -0,0 +1 @@
+#define MACRO_2A 1
Added: clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/NonIncludes/Level3A.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/NonIncludes/Level3A.h?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/NonIncludes/Level3A.h (added)
+++ clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/NonIncludes/Level3A.h Thu Feb 19 10:47:27 2015
@@ -0,0 +1 @@
+#define MACRO_3A 1
Added: clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/module.modulemap
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/module.modulemap?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/module.modulemap (added)
+++ clang-tools-extra/trunk/test/modularize/Inputs/CoverageNoProblems/module.modulemap Thu Feb 19 10:47:27 2015
@@ -0,0 +1,10 @@
+// module.map
+
+module Level1A {
+ header "Includes1/Level1A.h"
+ export *
+}
+module Level2A {
+ header "Includes2/Level2A.h"
+ export *
+}
Added: clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level1A.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level1A.h?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level1A.h (added)
+++ clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level1A.h Thu Feb 19 10:47:27 2015
@@ -0,0 +1,2 @@
+#include "Level2A.h"
+#define MACRO_1A 1
Added: clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level1B.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level1B.h?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level1B.h (added)
+++ clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level1B.h Thu Feb 19 10:47:27 2015
@@ -0,0 +1,2 @@
+#include "Level2B.h"
+#define MACRO_1B 1
Added: clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level2A.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level2A.h?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level2A.h (added)
+++ clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level2A.h Thu Feb 19 10:47:27 2015
@@ -0,0 +1 @@
+#define MACRO_2A 1
Added: clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level2B.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level2B.h?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level2B.h (added)
+++ clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level2B.h Thu Feb 19 10:47:27 2015
@@ -0,0 +1 @@
+#define MACRO_2B 1
Added: clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level3A.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level3A.h?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level3A.h (added)
+++ clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Level3A.h Thu Feb 19 10:47:27 2015
@@ -0,0 +1,2 @@
+#include "Sub/Level3B.h"
+#define MACRO_3A 1
Added: clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Sub/Level3B.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Sub/Level3B.h?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Sub/Level3B.h (added)
+++ clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/Sub/Level3B.h Thu Feb 19 10:47:27 2015
@@ -0,0 +1 @@
+#define MACRO_3B 1
Added: clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaFile.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaFile.h?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaFile.h (added)
+++ clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaFile.h Thu Feb 19 10:47:27 2015
@@ -0,0 +1,3 @@
+#define UMBRELLA_HEADER 1
+#include "UmbrellaInclude1.h"
+#include "UmbrellaInclude2.h"
Added: clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaInclude1.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaInclude1.h?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaInclude1.h (added)
+++ clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaInclude1.h Thu Feb 19 10:47:27 2015
@@ -0,0 +1 @@
+#define UMBRELLA_INCLUDE_1 1
Added: clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaInclude2.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaInclude2.h?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaInclude2.h (added)
+++ clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaInclude2.h Thu Feb 19 10:47:27 2015
@@ -0,0 +1 @@
+#define UMBRELLA_INCLUDE_2 1
Added: clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaSub/Umbrell1.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaSub/Umbrell1.h?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaSub/Umbrell1.h (added)
+++ clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaSub/Umbrell1.h Thu Feb 19 10:47:27 2015
@@ -0,0 +1 @@
+#define UMBRELLA_1 1
Added: clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaSub/Umbrell2.h
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaSub/Umbrell2.h?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaSub/Umbrell2.h (added)
+++ clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/UmbrellaSub/Umbrell2.h Thu Feb 19 10:47:27 2015
@@ -0,0 +1 @@
+#define UMBRELLA_2 1
Added: clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/module.modulemap
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/module.modulemap?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/module.modulemap (added)
+++ clang-tools-extra/trunk/test/modularize/Inputs/CoverageProblems/module.modulemap Thu Feb 19 10:47:27 2015
@@ -0,0 +1,30 @@
+// module.map
+
+module Level1A {
+ header "Level1A.h"
+ export *
+}
+module Level1B {
+ header "Level1B.h"
+ export *
+ module Level2B {
+ header "Level2B.h"
+ export *
+ }
+}
+module Level2A {
+ header "Level2A.h"
+ export *
+}
+module UmbrellaDirectoryModule {
+ umbrella "UmbrellaSub"
+}
+module UmbrellaHeaderModule {
+ umbrella header "UmbrellaFile.h"
+}
+/*
+module NoHeader {
+ header "NoHeader.h"
+ export *
+}
+*/
Modified: clang-tools-extra/trunk/test/modularize/NoProblems.modularize
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/NoProblems.modularize?rev=229869&r1=229868&r2=229869&view=diff
==============================================================================
--- clang-tools-extra/trunk/test/modularize/NoProblems.modularize (original)
+++ clang-tools-extra/trunk/test/modularize/NoProblems.modularize Thu Feb 19 10:47:27 2015
@@ -1,6 +1,6 @@
# RUN: modularize %s -x c++
# RUN: modularize -prefix=%p %s -x c++
-# RUN: modularize %S/Inputs/NoProblems.modulemap -x c++
+# RUN: modularize -no-coverage-check %S/Inputs/NoProblems.modulemap -x c++
Inputs/SomeTypes.h
Inputs/SomeDecls.h
Added: clang-tools-extra/trunk/test/modularize/NoProblemsCoverage.modularize
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/NoProblemsCoverage.modularize?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/NoProblemsCoverage.modularize (added)
+++ clang-tools-extra/trunk/test/modularize/NoProblemsCoverage.modularize Thu Feb 19 10:47:27 2015
@@ -0,0 +1 @@
+# RUN: modularize -I Includes1 -I Includes2 %S/Inputs/CoverageNoProblems/module.modulemap
Added: clang-tools-extra/trunk/test/modularize/ProblemsCoverage.modularize
URL: http://llvm.org/viewvc/llvm-project/clang-tools-extra/trunk/test/modularize/ProblemsCoverage.modularize?rev=229869&view=auto
==============================================================================
--- clang-tools-extra/trunk/test/modularize/ProblemsCoverage.modularize (added)
+++ clang-tools-extra/trunk/test/modularize/ProblemsCoverage.modularize Thu Feb 19 10:47:27 2015
@@ -0,0 +1,4 @@
+# RUN: not modularize %S/Inputs/CoverageProblems/module.modulemap 2>&1 | FileCheck %s
+
+# CHECK: warning: {{.*}}{{[/\\]}}Inputs/CoverageProblems/module.modulemap does not account for file: {{.*}}{{[/\\]}}Inputs/CoverageProblems/Level3A.h
+# CHECK-NEXT: warning: {{.*}}{{[/\\]}}Inputs/CoverageProblems/module.modulemap does not account for file: {{.*}}{{[/\\]}}Inputs/CoverageProblems/Sub/Level3B.h
More information about the cfe-commits
mailing list