//===- unittests/Frontend/CompilerInvocationTest.cpp - CI tests //---------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "clang/Frontend/CompilerInvocation.h"
#include "clang/Basic/TargetOptions.h"
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/TextDiagnosticBuffer.h"
#include "clang/Lex/PreprocessorOptions.h"
#include "clang/Serialization/ModuleFileExtension.h"
#include "llvm/Support/Host.h"

#include "gmock/gmock.h"
#include "gtest/gtest.h"

using namespace llvm;
using namespace clang;

using ::testing::Contains;
using ::testing::HasSubstr;
using ::testing::StrEq;

namespace {
class CommandLineTest : public ::testing::Test {
public:
  IntrusiveRefCntPtr<DiagnosticsEngine> Diags;
  SmallVector<const char *, 32> GeneratedArgs;
  SmallVector<std::string, 32> GeneratedArgsStorage;
  CompilerInvocation Invocation;

  const char *operator()(const Twine &Arg) {
    return GeneratedArgsStorage.emplace_back(Arg.str()).c_str();
  }

  CommandLineTest()
      : Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions(),
                                                  new TextDiagnosticBuffer())) {
  }
};

template <typename M>
std::string describeContainsN(M InnerMatcher, unsigned N, bool Negation) {
  StringRef Contains = Negation ? "doesn't contain" : "contains";
  StringRef Instance = N == 1 ? " instance " : " instances ";
  StringRef Element = "of element that ";

  std::ostringstream Inner;
  InnerMatcher.impl().DescribeTo(&Inner);

  return (Contains + " exactly " + Twine(N) + Instance + Element + Inner.str())
      .str();
}

MATCHER_P2(ContainsN, InnerMatcher, N,
           describeContainsN(InnerMatcher, N, negation)) {
  auto InnerMatches = [this](const auto &Element) {
    ::testing::internal::DummyMatchResultListener InnerListener;
    return InnerMatcher.impl().MatchAndExplain(Element, &InnerListener);
  };

  return count_if(arg, InnerMatches) == N;
}

TEST(ContainsN, Empty) {
  const char *Array[] = {""};

  ASSERT_THAT(Array, ContainsN(StrEq("x"), 0));
  ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 1)));
  ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 2)));
}

TEST(ContainsN, Zero) {
  const char *Array[] = {"y"};

  ASSERT_THAT(Array, ContainsN(StrEq("x"), 0));
  ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 1)));
  ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 2)));
}

TEST(ContainsN, One) {
  const char *Array[] = {"a", "b", "x", "z"};

  ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 0)));
  ASSERT_THAT(Array, ContainsN(StrEq("x"), 1));
  ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 2)));
}

TEST(ContainsN, Two) {
  const char *Array[] = {"x", "a", "b", "x"};

  ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 0)));
  ASSERT_THAT(Array, Not(ContainsN(StrEq("x"), 1)));
  ASSERT_THAT(Array, ContainsN(StrEq("x"), 2));
}

// Copy constructor/assignment perform deep copy of reference-counted pointers.

TEST(CompilerInvocationTest, DeepCopyConstructor) {
  CompilerInvocation A;
  A.getAnalyzerOpts()->Config["Key"] = "Old";

  CompilerInvocation B(A);
  B.getAnalyzerOpts()->Config["Key"] = "New";

  ASSERT_EQ(A.getAnalyzerOpts()->Config["Key"], "Old");
}

TEST(CompilerInvocationTest, DeepCopyAssignment) {
  CompilerInvocation A;
  A.getAnalyzerOpts()->Config["Key"] = "Old";

  CompilerInvocation B;
  B = A;
  B.getAnalyzerOpts()->Config["Key"] = "New";

  ASSERT_EQ(A.getAnalyzerOpts()->Config["Key"], "Old");
}

// Boolean option with a keypath that defaults to true.
// The only flag with a negative spelling can set the keypath to false.

TEST_F(CommandLineTest, BoolOptionDefaultTrueSingleFlagNotPresent) {
  const char *Args[] = {""};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_TRUE(Invocation.getFrontendOpts().UseTemporary);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-temp-file"))));
}

TEST_F(CommandLineTest, BoolOptionDefaultTrueSingleFlagPresent) {
  const char *Args[] = {"-fno-temp-file"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_FALSE(Invocation.getFrontendOpts().UseTemporary);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fno-temp-file")));
}

TEST_F(CommandLineTest, BoolOptionDefaultTrueSingleFlagUnknownPresent) {
  const char *Args[] = {"-ftemp-file"};

  // Driver-only flag.
  ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_TRUE(Invocation.getFrontendOpts().UseTemporary);
}

// Boolean option with a keypath that defaults to true.
// The flag with negative spelling can set the keypath to false.
// The flag with positive spelling can reset the keypath to true.

TEST_F(CommandLineTest, BoolOptionDefaultTruePresentNone) {
  const char *Args[] = {""};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_TRUE(Invocation.getCodeGenOpts().Autolink);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fautolink"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-autolink"))));
}

TEST_F(CommandLineTest, BoolOptionDefaultTruePresentNegChange) {
  const char *Args[] = {"-fno-autolink"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_FALSE(Invocation.getCodeGenOpts().Autolink);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);
  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fno-autolink")));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fautolink"))));
}

TEST_F(CommandLineTest, BoolOptionDefaultTruePresentPosReset) {
  const char *Args[] = {"-fautolink"};

  // Driver-only flag.
  ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_TRUE(Invocation.getCodeGenOpts().Autolink);
}

// Boolean option with a keypath that defaults to false.
// The flag with negative spelling can set the keypath to true.
// The flag with positive spelling can reset the keypath to false.

TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNone) {
  const char *Args[] = {""};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_FALSE(Invocation.getCodeGenOpts().NoInlineLineTables);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-ginline-line-tables"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gno-inline-line-tables"))));
}

TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNegChange) {
  const char *Args[] = {"-gno-inline-line-tables"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_TRUE(Invocation.getCodeGenOpts().NoInlineLineTables);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);
  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-gno-inline-line-tables")));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-ginline-line-tables"))));
}

TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentPosReset) {
  const char *Args[] = {"-ginline-line-tables"};

  // Driver-only flag.
  ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_FALSE(Invocation.getCodeGenOpts().NoInlineLineTables);
}

// Boolean option with a keypath that defaults to false.
// The flag with positive spelling can set the keypath to true.
// The flag with negative spelling can reset the keypath to false.

TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNoneX) {
  const char *Args[] = {""};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_FALSE(Invocation.getCodeGenOpts().CodeViewGHash);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gcodeview-ghash"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gno-codeview-ghash"))));
}

TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentPosChange) {
  const char *Args[] = {"-gcodeview-ghash"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_TRUE(Invocation.getCodeGenOpts().CodeViewGHash);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);
  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-gcodeview-ghash")));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-gno-codeview-ghash"))));
}

TEST_F(CommandLineTest, BoolOptionDefaultFalsePresentNegReset) {
  const char *Args[] = {"-gno-codeview-ghash"};

  // Driver-only flag.
  ASSERT_FALSE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_FALSE(Invocation.getCodeGenOpts().CodeViewGHash);
}

// Boolean option with a keypath that defaults to an arbitrary expression.
// The flag with positive spelling can set the keypath to true.
// The flag with negative spelling can set the keypath to false.

static constexpr unsigned PassManagerDefault =
    !static_cast<unsigned>(LLVM_ENABLE_NEW_PASS_MANAGER);

static constexpr const char *PassManagerResetByFlag =
    LLVM_ENABLE_NEW_PASS_MANAGER ? "-fno-legacy-pass-manager"
                                 : "-flegacy-pass-manager";

static constexpr const char *PassManagerChangedByFlag =
    LLVM_ENABLE_NEW_PASS_MANAGER ? "-flegacy-pass-manager"
                                 : "-fno-legacy-pass-manager";

TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentNone) {
  const char *Args = {""};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_EQ(Invocation.getCodeGenOpts().LegacyPassManager, PassManagerDefault);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerResetByFlag))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerChangedByFlag))));
}

TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentChange) {
  const char *Args[] = {PassManagerChangedByFlag};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_EQ(Invocation.getCodeGenOpts().LegacyPassManager, !PassManagerDefault);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);
  ASSERT_THAT(GeneratedArgs, Contains(StrEq(PassManagerChangedByFlag)));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerResetByFlag))));
}

TEST_F(CommandLineTest, BoolOptionDefaultArbitraryTwoFlagsPresentReset) {
  const char *Args[] = {PassManagerResetByFlag};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_EQ(Invocation.getCodeGenOpts().LegacyPassManager, PassManagerDefault);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerResetByFlag))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq(PassManagerChangedByFlag))));
}

// Boolean option that gets the CC1Option flag from a let statement (which
// is applied **after** the record is defined):
//
//   let Flags = [CC1Option] in {
//     defm option : BoolOption<...>;
//   }

TEST_F(CommandLineTest, BoolOptionCC1ViaLetPresentNone) {
  const char *Args[] = {""};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_FALSE(Invocation.getCodeGenOpts().DebugPassManager);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdebug-pass-manager"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-debug-pass-manager"))));
}

TEST_F(CommandLineTest, BoolOptionCC1ViaLetPresentPos) {
  const char *Args[] = {"-fdebug-pass-manager"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_TRUE(Invocation.getCodeGenOpts().DebugPassManager);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fdebug-pass-manager"), 1));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-debug-pass-manager"))));
}

TEST_F(CommandLineTest, BoolOptionCC1ViaLetPresentNeg) {
  const char *Args[] = {"-fno-debug-pass-manager"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_FALSE(Invocation.getCodeGenOpts().DebugPassManager);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-debug-pass-manager"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdebug-pass-manager"))));
}

TEST_F(CommandLineTest, CanGenerateCC1CommandLineFlag) {
  const char *Args[] = {"-fmodules-strict-context-hash"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fmodules-strict-context-hash")));
}

TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparate) {
  const char *TripleCStr = "i686-apple-darwin9";
  const char *Args[] = {"-triple", TripleCStr};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, Contains(StrEq(TripleCStr)));
}

TEST_F(CommandLineTest,  CanGenerateCC1CommandLineSeparateRequiredPresent) {
  const std::string DefaultTriple =
      llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
  const char *Args[] = {"-triple", DefaultTriple.c_str()};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  // Triple should always be emitted even if it is the default
  ASSERT_THAT(GeneratedArgs, Contains(StrEq(DefaultTriple.c_str())));
}

TEST_F(CommandLineTest, CanGenerateCC1CommandLineSeparateRequiredAbsent) {
  const std::string DefaultTriple =
      llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
  const char *Args[] = {""};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  // Triple should always be emitted even if it is the default
  ASSERT_THAT(GeneratedArgs, Contains(StrEq(DefaultTriple.c_str())));
}

TEST_F(CommandLineTest, SeparateEnumNonDefault) {
  const char *Args[] = {"-mrelocation-model", "static"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_EQ(Invocation.getCodeGenOpts().RelocationModel, Reloc::Model::Static);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  // Non default relocation model.
  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-mrelocation-model")));
  ASSERT_THAT(GeneratedArgs, Contains(StrEq("static")));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model=static"))));
}

TEST_F(CommandLineTest, SeparateEnumDefault) {
  const char *Args[] = {"-mrelocation-model", "pic"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_EQ(Invocation.getCodeGenOpts().RelocationModel, Reloc::Model::PIC_);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  // Default relocation model.
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("pic"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-mrelocation-model=pic"))));
}

TEST_F(CommandLineTest, JoinedEnumNonDefault) {
  const char *Args[] = {"-fobjc-dispatch-method=non-legacy"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_EQ(Invocation.getCodeGenOpts().getObjCDispatchMethod(),
            CodeGenOptions::NonLegacy);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs,
              Contains(StrEq("-fobjc-dispatch-method=non-legacy")));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fobjc-dispatch-method="))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("non-legacy"))));
}

TEST_F(CommandLineTest, JoinedEnumDefault) {
  const char *Args[] = {"-fobjc-dispatch-method=legacy"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_EQ(Invocation.getCodeGenOpts().getObjCDispatchMethod(),
            CodeGenOptions::Legacy);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs,
              Not(Contains(StrEq("-fobjc-dispatch-method=legacy"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fobjc-dispatch-method="))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("legacy"))));
}

TEST_F(CommandLineTest, StringVectorEmpty) {
  const char *Args[] = {""};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_TRUE(Invocation.getFrontendOpts().ModuleMapFiles.empty());

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, Not(Contains(HasSubstr("-fmodule-map-file"))));
}

TEST_F(CommandLineTest, StringVectorSingle) {
  const char *Args[] = {"-fmodule-map-file=a"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_EQ(Invocation.getFrontendOpts().ModuleMapFiles,
            std::vector<std::string>({"a"}));

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fmodule-map-file=a"), 1));
  ASSERT_THAT(GeneratedArgs, ContainsN(HasSubstr("-fmodule-map-file"), 1));
}

TEST_F(CommandLineTest, StringVectorMultiple) {
  const char *Args[] = {"-fmodule-map-file=a", "-fmodule-map-file=b"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_TRUE(Invocation.getFrontendOpts().ModuleMapFiles ==
              std::vector<std::string>({"a", "b"}));

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fmodule-map-file=a"), 1));
  ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-fmodule-map-file=b"), 1));
  ASSERT_THAT(GeneratedArgs, ContainsN(HasSubstr("-fmodule-map-file"), 2));
}

// CommaJoined option with MarshallingInfoStringVector.

TEST_F(CommandLineTest, StringVectorCommaJoinedNone) {
  const char *Args[] = {""};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_TRUE(Invocation.getLangOpts()->CommentOpts.BlockCommandNames.empty());

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs,
              Not(Contains(HasSubstr("-fcomment-block-commands"))));
}

TEST_F(CommandLineTest, StringVectorCommaJoinedSingle) {
  const char *Args[] = {"-fcomment-block-commands=x,y"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_EQ(Invocation.getLangOpts()->CommentOpts.BlockCommandNames,
            std::vector<std::string>({"x", "y"}));

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs,
              ContainsN(StrEq("-fcomment-block-commands=x,y"), 1));
}

TEST_F(CommandLineTest, StringVectorCommaJoinedMultiple) {
  const char *Args[] = {"-fcomment-block-commands=x,y",
                        "-fcomment-block-commands=a,b"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_EQ(Invocation.getLangOpts()->CommentOpts.BlockCommandNames,
            std::vector<std::string>({"x", "y", "a", "b"}));

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs,
              ContainsN(StrEq("-fcomment-block-commands=x,y,a,b"), 1));
}

// A flag that should be parsed only if a condition is met.

TEST_F(CommandLineTest, ConditionalParsingIfFalseFlagNotPresent) {
  const char *Args[] = {""};

  CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

  ASSERT_FALSE(Diags->hasErrorOccurred());
  ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsDevice);
  ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsHost);
  ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_None);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fsycl"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(HasSubstr("-sycl-std="))));
}

TEST_F(CommandLineTest, ConditionalParsingIfFalseFlagPresent) {
  const char *Args[] = {"-sycl-std=2017"};

  CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

  ASSERT_FALSE(Diags->hasErrorOccurred());
  ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsDevice);
  ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsHost);
  ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_None);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fsycl-is-device"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fsycl-is-host"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(HasSubstr("-sycl-std="))));
}

TEST_F(CommandLineTest, ConditionalParsingIfNonsenseSyclStdArg) {
  const char *Args[] = {"-fsycl-is-device", "-sycl-std=garbage"};

  CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

  ASSERT_TRUE(Diags->hasErrorOccurred());
  ASSERT_TRUE(Invocation.getLangOpts()->SYCLIsDevice);
  ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsHost);
  ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_None);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fsycl-is-device")));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fsycl-is-host"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(HasSubstr("-sycl-std="))));
}

TEST_F(CommandLineTest, ConditionalParsingIfOddSyclStdArg1) {
  const char *Args[] = {"-fsycl-is-device", "-sycl-std=121"};

  CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

  ASSERT_FALSE(Diags->hasErrorOccurred());
  ASSERT_TRUE(Invocation.getLangOpts()->SYCLIsDevice);
  ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsHost);
  ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_2017);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fsycl-is-device")));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fsycl-is-host"))));
  ASSERT_THAT(GeneratedArgs, Contains(HasSubstr("-sycl-std=2017")));
}

TEST_F(CommandLineTest, ConditionalParsingIfOddSyclStdArg2) {
  const char *Args[] = {"-fsycl-is-device", "-sycl-std=1.2.1"};

  CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

  ASSERT_FALSE(Diags->hasErrorOccurred());
  ASSERT_TRUE(Invocation.getLangOpts()->SYCLIsDevice);
  ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsHost);
  ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_2017);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fsycl-is-device")));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fsycl-is-host"))));
  ASSERT_THAT(GeneratedArgs, Contains(HasSubstr("-sycl-std=2017")));
}

TEST_F(CommandLineTest, ConditionalParsingIfOddSyclStdArg3) {
  const char *Args[] = {"-fsycl-is-device", "-sycl-std=sycl-1.2.1"};

  CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

  ASSERT_FALSE(Diags->hasErrorOccurred());
  ASSERT_TRUE(Invocation.getLangOpts()->SYCLIsDevice);
  ASSERT_FALSE(Invocation.getLangOpts()->SYCLIsHost);
  ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_2017);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fsycl-is-device")));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fsycl-is-host"))));
  ASSERT_THAT(GeneratedArgs, Contains(HasSubstr("-sycl-std=2017")));
}

TEST_F(CommandLineTest, ConditionalParsingIfTrueFlagNotPresentHost) {
  const char *Args[] = {"-fsycl-is-host"};

  CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

  ASSERT_FALSE(Diags->hasErrorOccurred());
  ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(),
            LangOptions::SYCL_Default);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fsycl-is-host")));
  ASSERT_THAT(GeneratedArgs, Contains(HasSubstr("-sycl-std=")));
}

TEST_F(CommandLineTest, ConditionalParsingIfTrueFlagNotPresentDevice) {
  const char *Args[] = {"-fsycl-is-device"};

  CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

  ASSERT_FALSE(Diags->hasErrorOccurred());
  ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(),
            LangOptions::SYCL_Default);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fsycl-is-device")));
  ASSERT_THAT(GeneratedArgs, Contains(HasSubstr("-sycl-std=")));
}

TEST_F(CommandLineTest, ConditionalParsingIfTrueFlagPresent) {
  const char *Args[] = {"-fsycl-is-device", "-sycl-std=2017"};

  CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

  ASSERT_FALSE(Diags->hasErrorOccurred());
  ASSERT_EQ(Invocation.getLangOpts()->getSYCLVersion(), LangOptions::SYCL_2017);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fsycl-is-device")));
  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-sycl-std=2017")));
}

// Wide integer option.

TEST_F(CommandLineTest, WideIntegerHighValue) {
  const char *Args[] = {"-fbuild-session-timestamp=1609827494445723662"};

  CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags);

  ASSERT_FALSE(Diags->hasErrorOccurred());
  ASSERT_EQ(Invocation.getHeaderSearchOpts().BuildSessionTimestamp,
            1609827494445723662ull);
}

// Tree of boolean options that can be (directly or transitively) implied by
// their parent:
//
//   * -cl-unsafe-math-optimizations
//     * -cl-mad-enable
//     * -menable-unsafe-fp-math
//       * -freciprocal-math

TEST_F(CommandLineTest, ImpliedBoolOptionsNoFlagPresent) {
  const char *Args[] = {""};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_FALSE(Invocation.getLangOpts()->CLUnsafeMath);
  ASSERT_FALSE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
  ASSERT_FALSE(Invocation.getLangOpts()->UnsafeFPMath);
  ASSERT_FALSE(Invocation.getLangOpts()->AllowRecip);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  // Not generated - missing.
  ASSERT_THAT(GeneratedArgs,
              Not(Contains(StrEq("-cl-unsafe-math-optimizations"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-freciprocal-math"))));
}

TEST_F(CommandLineTest, ImpliedBoolOptionsRootFlagPresent) {
  const char *Args[] = {"-cl-unsafe-math-optimizations"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  // Explicitly provided root flag.
  ASSERT_TRUE(Invocation.getLangOpts()->CLUnsafeMath);
  // Directly implied by explicitly provided root flag.
  ASSERT_TRUE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
  ASSERT_TRUE(Invocation.getLangOpts()->UnsafeFPMath);
  // Transitively implied by explicitly provided root flag.
  ASSERT_TRUE(Invocation.getLangOpts()->AllowRecip);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  // Generated - explicitly provided.
  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-unsafe-math-optimizations")));
  // Not generated - implied by the generated root flag.
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-freciprocal-math"))));
}

TEST_F(CommandLineTest, ImpliedBoolOptionsAllFlagsPresent) {
  const char *Args[] = {"-cl-unsafe-math-optimizations", "-cl-mad-enable",
                        "-menable-unsafe-fp-math", "-freciprocal-math"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_TRUE(Invocation.getLangOpts()->CLUnsafeMath);
  ASSERT_TRUE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
  ASSERT_TRUE(Invocation.getLangOpts()->UnsafeFPMath);
  ASSERT_TRUE(Invocation.getLangOpts()->AllowRecip);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  // Generated - explicitly provided.
  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-unsafe-math-optimizations")));
  // Not generated - implied by their generated parent.
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-cl-mad-enable"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-menable-unsafe-fp-math"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-freciprocal-math"))));
}

TEST_F(CommandLineTest, ImpliedBoolOptionsImpliedFlagsPresent) {
  const char *Args[] = {"-cl-mad-enable", "-menable-unsafe-fp-math",
                        "-freciprocal-math"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_FALSE(Invocation.getLangOpts()->CLUnsafeMath);
  ASSERT_TRUE(Invocation.getCodeGenOpts().LessPreciseFPMAD);
  ASSERT_TRUE(Invocation.getLangOpts()->UnsafeFPMath);
  ASSERT_TRUE(Invocation.getLangOpts()->AllowRecip);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);
  // Not generated - missing.
  ASSERT_THAT(GeneratedArgs,
              Not(Contains(StrEq("-cl-unsafe-math-optimizations"))));
  // Generated - explicitly provided.
  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-mad-enable")));
  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-menable-unsafe-fp-math")));
  // Not generated - implied by its generated parent.
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-freciprocal-math"))));
}

TEST_F(CommandLineTest, PresentAndNotImpliedGenerated) {
  const char *Args[] = {"-cl-mad-enable", "-menable-unsafe-fp-math"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  // Present options that were not implied are generated.
  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-cl-mad-enable")));
  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-menable-unsafe-fp-math")));
}

// Diagnostic option.

TEST_F(CommandLineTest, DiagnosticOptionPresent) {
  const char *Args[] = {"-verify=xyz"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));

  ASSERT_EQ(Invocation.getDiagnosticOpts().VerifyPrefixes,
            std::vector<std::string>({"xyz"}));

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs, ContainsN(StrEq("-verify=xyz"), 1));
}

// Option default depends on language standard.

TEST_F(CommandLineTest, DigraphsImplied) {
  const char *Args[] = {""};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_TRUE(Invocation.getLangOpts()->Digraphs);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-digraphs"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdigraphs"))));
}

TEST_F(CommandLineTest, DigraphsDisabled) {
  const char *Args[] = {"-fno-digraphs"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_FALSE(Invocation.getLangOpts()->Digraphs);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);
  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fno-digraphs")));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdigraphs"))));
}

TEST_F(CommandLineTest, DigraphsNotImplied) {
  const char *Args[] = {"-std=c89"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_FALSE(Invocation.getLangOpts()->Digraphs);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fno-digraphs"))));
  ASSERT_THAT(GeneratedArgs, Not(Contains(StrEq("-fdigraphs"))));
}

TEST_F(CommandLineTest, DigraphsEnabled) {
  const char *Args[] = {"-std=c89", "-fdigraphs"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_TRUE(Invocation.getLangOpts()->Digraphs);

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);
  ASSERT_THAT(GeneratedArgs, Contains(StrEq("-fdigraphs")));
}

struct DummyModuleFileExtension
    : public llvm::RTTIExtends<DummyModuleFileExtension, ModuleFileExtension> {
  static char ID;

  ModuleFileExtensionMetadata getExtensionMetadata() const override {
    return {};
  };

  void hashExtension(ExtensionHashBuilder &HBuilder) const override {}

  std::unique_ptr<ModuleFileExtensionWriter>
  createExtensionWriter(ASTWriter &Writer) override {
    return {};
  }

  std::unique_ptr<ModuleFileExtensionReader>
  createExtensionReader(const ModuleFileExtensionMetadata &Metadata,
                        ASTReader &Reader, serialization::ModuleFile &Mod,
                        const llvm::BitstreamCursor &Stream) override {
    return {};
  }
};

char DummyModuleFileExtension::ID = 0;

TEST_F(CommandLineTest, TestModuleFileExtension) {
  const char *Args[] = {"-ftest-module-file-extension=first:2:1:0:first",
                        "-ftest-module-file-extension=second:3:2:1:second"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
  ASSERT_THAT(Invocation.getFrontendOpts().ModuleFileExtensions.size(), 2);

  // Exercise the check that only serializes instances of
  // TestModuleFileExtension by providing an instance of another
  // ModuleFileExtension subclass.
  Invocation.getFrontendOpts().ModuleFileExtensions.push_back(
      std::make_shared<DummyModuleFileExtension>());

  Invocation.generateCC1CommandLine(GeneratedArgs, *this);

  ASSERT_THAT(GeneratedArgs,
              ContainsN(HasSubstr("-ftest-module-file-extension="), 2));
  ASSERT_THAT(
      GeneratedArgs,
      Contains(StrEq("-ftest-module-file-extension=first:2:1:0:first")));
  ASSERT_THAT(
      GeneratedArgs,
      Contains(StrEq("-ftest-module-file-extension=second:3:2:1:second")));
}

TEST_F(CommandLineTest, RoundTrip) {
  // Testing one marshalled and one manually generated option from each
  // CompilerInvocation member.
  const char *Args[] = {
      "-round-trip-args",
      // LanguageOptions
      "-std=c17",
      "-fmax-tokens=10",
      // TargetOptions
      "-target-sdk-version=1.2.3",
      "-meabi",
      "4",
      // DiagnosticOptions
      "-Wundef-prefix=XY",
      "-fdiagnostics-format",
      "clang",
      // HeaderSearchOptions
      "-stdlib=libc++",
      "-fimplicit-module-maps",
      // PreprocessorOptions
      "-DXY=AB",
      "-include-pch",
      "a.pch",
      // AnalyzerOptions
      "-analyzer-config",
      "ctu-import-threshold=42",
      "-unoptimized-cfg",
      // MigratorOptions (no manually handled arguments)
      "-no-ns-alloc-error",
      // CodeGenOptions
      "-debug-info-kind=limited",
      "-debug-info-macro",
      // DependencyOutputOptions
      "--show-includes",
      "-H",
      // FileSystemOptions (no manually handled arguments)
      "-working-directory",
      "folder",
      // FrontendOptions
      "-load",
      "plugin",
      "-ast-merge",
      // PreprocessorOutputOptions
      "-dD",
      "-CC",
  };

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));

  ASSERT_TRUE(Invocation.getLangOpts()->C17);
  ASSERT_EQ(Invocation.getLangOpts()->MaxTokens, 10u);

  ASSERT_EQ(Invocation.getTargetOpts().SDKVersion, llvm::VersionTuple(1, 2, 3));
  ASSERT_EQ(Invocation.getTargetOpts().EABIVersion, EABI::EABI4);

  ASSERT_THAT(Invocation.getDiagnosticOpts().UndefPrefixes,
              Contains(StrEq("XY")));
  ASSERT_EQ(Invocation.getDiagnosticOpts().getFormat(),
            TextDiagnosticFormat::Clang);

  ASSERT_TRUE(Invocation.getHeaderSearchOpts().UseLibcxx);
  ASSERT_TRUE(Invocation.getHeaderSearchOpts().ImplicitModuleMaps);

  ASSERT_THAT(Invocation.getPreprocessorOpts().Macros,
              Contains(std::make_pair(std::string("XY=AB"), false)));
  ASSERT_EQ(Invocation.getPreprocessorOpts().ImplicitPCHInclude, "a.pch");

  ASSERT_EQ(Invocation.getAnalyzerOpts()->Config["ctu-import-threshold"], "42");
  ASSERT_TRUE(Invocation.getAnalyzerOpts()->UnoptimizedCFG);

  ASSERT_TRUE(Invocation.getMigratorOpts().NoNSAllocReallocError);

  ASSERT_EQ(Invocation.getCodeGenOpts().getDebugInfo(),
            codegenoptions::DebugInfoKind::LimitedDebugInfo);
  ASSERT_TRUE(Invocation.getCodeGenOpts().MacroDebugInfo);

  ASSERT_EQ(Invocation.getDependencyOutputOpts().ShowIncludesDest,
            ShowIncludesDestination::Stdout);
  ASSERT_TRUE(Invocation.getDependencyOutputOpts().ShowHeaderIncludes);
}

TEST_F(CommandLineTest, PluginArgsRoundTripDeterminism) {
  const char *Args[] = {
      "-plugin-arg-blink-gc-plugin", "no-members-in-stack-allocated",
      "-plugin-arg-find-bad-constructs", "checked-ptr-as-trivial-member",
      "-plugin-arg-find-bad-constructs", "check-ipc",
      // Enable round-trip to ensure '-plugin-arg' generation is deterministic.
      "-round-trip-args"};

  ASSERT_TRUE(CompilerInvocation::CreateFromArgs(Invocation, Args, *Diags));
}
} // anonymous namespace