clang/unittests/Frontend/ASTUnitTest.cpp

   1 //===- unittests/Frontend/ASTUnitTest.cpp - ASTUnit tests -----------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include <fstream>
  10
  11 #include "clang/Basic/FileManager.h"
  12 #include "clang/Frontend/ASTUnit.h"
  13 #include "clang/Frontend/CompilerInstance.h"
  14 #include "clang/Frontend/CompilerInvocation.h"
  15 #include "clang/Frontend/PCHContainerOperations.h"
  16 #include "clang/Lex/HeaderSearch.h"
  17 #include "llvm/Support/FileSystem.h"
  18 #include "llvm/Support/Path.h"
  19 #include "llvm/Support/ToolOutputFile.h"
  20 #include "gtest/gtest.h"
  21
  22 using namespace llvm;
  23 using namespace clang;
  24
  25 namespace {
  26
  27 class ASTUnitTest : public ::testing::Test {
  28 protected:
  29   int FD;
  30   llvm::SmallString<256> InputFileName;
  31   std::unique_ptr<ToolOutputFile> input_file;
  32   IntrusiveRefCntPtr<DiagnosticsEngine> Diags;
  33   std::shared_ptr<CompilerInvocation> CInvok;
  34   std::shared_ptr<PCHContainerOperations> PCHContainerOps;
  35
  36   std::unique_ptr<ASTUnit> createASTUnit(bool isVolatile) {
  37     EXPECT_FALSE(llvm::sys::fs::createTemporaryFile("ast-unit", "cpp", FD,
  38                                                     InputFileName));
  39     input_file = std::make_unique<ToolOutputFile>(InputFileName, FD);
  40     input_file->os() << "";
  41
  42     const char *Args[] = {"clang", "-xc++", InputFileName.c_str()};
  43
  44     Diags = CompilerInstance::createDiagnostics(new DiagnosticOptions());
  45
  46     CInvok = createInvocationFromCommandLine(Args, Diags);
  47
  48     if (!CInvok)
  49       return nullptr;
  50
  51     FileManager *FileMgr =
  52         new FileManager(FileSystemOptions(), vfs::getRealFileSystem());
  53     PCHContainerOps = std::make_shared<PCHContainerOperations>();
  54
  55     return ASTUnit::LoadFromCompilerInvocation(
  56         CInvok, PCHContainerOps, Diags, FileMgr, false, CaptureDiagsKind::None,
  57         0, TU_Complete, false, false, isVolatile);
  58   }
  59 };
  60
  61 TEST_F(ASTUnitTest, SaveLoadPreservesLangOptionsInPrintingPolicy) {
  62   // Check that the printing policy is restored with the correct language
  63   // options when loading an ASTUnit from a file.  To this end, an ASTUnit
  64   // for a C++ translation unit is set up and written to a temporary file.
  65
  66   // By default `UseVoidForZeroParams` is true for non-C++ language options,
  67   // thus we can check this field after loading the ASTUnit to deduce whether
  68   // the correct (C++) language options were used when setting up the printing
  69   // policy.
  70
  71   {
  72     PrintingPolicy PolicyWithDefaultLangOpt(LangOptions{});
  73     EXPECT_TRUE(PolicyWithDefaultLangOpt.UseVoidForZeroParams);
  74   }
  75
  76   std::unique_ptr<ASTUnit> AST = createASTUnit(false);
  77
  78   if (!AST)
  79     FAIL() << "failed to create ASTUnit";
  80
  81   EXPECT_FALSE(AST->getASTContext().getPrintingPolicy().UseVoidForZeroParams);
  82
  83   llvm::SmallString<256> ASTFileName;
  84   ASSERT_FALSE(
  85       llvm::sys::fs::createTemporaryFile("ast-unit", "ast", FD, ASTFileName));
  86   ToolOutputFile ast_file(ASTFileName, FD);
  87   AST->Save(ASTFileName.str());
  88
  89   EXPECT_TRUE(llvm::sys::fs::exists(ASTFileName));
  90
  91   std::unique_ptr<ASTUnit> AU = ASTUnit::LoadFromASTFile(
  92       std::string(ASTFileName.str()), PCHContainerOps->getRawReader(),
  93       ASTUnit::LoadEverything, Diags, FileSystemOptions(),
  94       /*UseDebugInfo=*/false);
  95
  96   if (!AU)
  97     FAIL() << "failed to load ASTUnit";
  98
  99   EXPECT_FALSE(AU->getASTContext().getPrintingPolicy().UseVoidForZeroParams);
 100 }
 101
 102 TEST_F(ASTUnitTest, GetBufferForFileMemoryMapping) {
 103   std::unique_ptr<ASTUnit> AST = createASTUnit(true);
 104
 105   if (!AST)
 106     FAIL() << "failed to create ASTUnit";
 107
 108   std::unique_ptr<llvm::MemoryBuffer> memoryBuffer =
 109       AST->getBufferForFile(InputFileName);
 110
 111   EXPECT_NE(memoryBuffer->getBufferKind(),
 112             llvm::MemoryBuffer::MemoryBuffer_MMap);
 113 }
 114
 115 TEST_F(ASTUnitTest, ModuleTextualHeader) {
 116   llvm::IntrusiveRefCntPtr<llvm::vfs::InMemoryFileSystem> InMemoryFs =
 117       new llvm::vfs::InMemoryFileSystem();
 118   InMemoryFs->addFile("test.cpp", 0, llvm::MemoryBuffer::getMemBuffer(R"cpp(
 119       #include "Textual.h"
 120       void foo() {}
 121     )cpp"));
 122   InMemoryFs->addFile("m.modulemap", 0, llvm::MemoryBuffer::getMemBuffer(R"cpp(
 123       module M {
 124         module Textual {
 125           textual header "Textual.h"
 126         }
 127       }
 128     )cpp"));
 129   InMemoryFs->addFile("Textual.h", 0, llvm::MemoryBuffer::getMemBuffer(R"cpp(
 130       void foo();
 131     )cpp"));
 132
 133   const char *Args[] = {"clang", "test.cpp", "-fmodule-map-file=m.modulemap",
 134                         "-fmodule-name=M"};
 135   Diags = CompilerInstance::createDiagnostics(new DiagnosticOptions());
 136   CInvok = createInvocationFromCommandLine(Args, Diags);
 137   ASSERT_TRUE(CInvok);
 138
 139   FileManager *FileMgr = new FileManager(FileSystemOptions(), InMemoryFs);
 140   PCHContainerOps = std::make_shared<PCHContainerOperations>();
 141
 142   auto AU = ASTUnit::LoadFromCompilerInvocation(
 143       CInvok, PCHContainerOps, Diags, FileMgr, false, CaptureDiagsKind::None, 1,
 144       TU_Complete, false, false, false);
 145   ASSERT_TRUE(AU);
 146   auto File = AU->getFileManager().getFileRef("Textual.h", false, false);
 147   ASSERT_TRUE(bool(File));
 148   // Verify that we do not crash here.
 149   EXPECT_TRUE(AU->getPreprocessor().getHeaderSearchInfo().getExistingFileInfo(
 150       &File->getFileEntry()));
 151 }
 152
 153 TEST_F(ASTUnitTest, LoadFromCommandLineEarlyError) {
 154   EXPECT_FALSE(
 155       llvm::sys::fs::createTemporaryFile("ast-unit", "c", FD, InputFileName));
 156   input_file = std::make_unique<ToolOutputFile>(InputFileName, FD);
 157   input_file->os() << "";
 158
 159   const char *Args[] = {"clang", "-target", "foobar", InputFileName.c_str()};
 160
 161   auto Diags = CompilerInstance::createDiagnostics(new DiagnosticOptions());
 162   auto PCHContainerOps = std::make_shared<PCHContainerOperations>();
 163   std::unique_ptr<clang::ASTUnit> ErrUnit;
 164
 165   ASTUnit *AST = ASTUnit::LoadFromCommandLine(
 166       &Args[0], &Args[4], PCHContainerOps, Diags, "", false,
 167       CaptureDiagsKind::All, None, true, 0, TU_Complete, false, false, false,
 168       SkipFunctionBodiesScope::None, false, true, false, false, None, &ErrUnit,
 169       nullptr);
 170
 171   ASSERT_EQ(AST, nullptr);
 172   ASSERT_NE(ErrUnit, nullptr);
 173   ASSERT_TRUE(Diags->hasErrorOccurred());
 174   ASSERT_NE(ErrUnit->stored_diag_size(), 0U);
 175 }
 176
 177 } // anonymous namespace