FS.Files[Path] = Code;
runAddDocument(Server, Path, Code);
- auto Replaces = runFormatFile(Server, Path, /*Rng=*/llvm::None);
+ auto Replaces = runFormatFile(Server, Path, /*Rng=*/std::nullopt);
EXPECT_TRUE(static_cast<bool>(Replaces));
auto Changed = tooling::applyAllReplacements(Code, *Replaces);
EXPECT_TRUE(static_cast<bool>(Changed));
// heuristics as normal and reports a range. It'd be nice to be consistent.
const char *NoCompletion = "/* foo [[]]^ */";
Completions = completions(NoCompletion);
- EXPECT_EQ(Completions.CompletionRange, llvm::None);
+ EXPECT_EQ(Completions.CompletionRange, std::nullopt);
Completions = completionsNoCompile(NoCompletion);
EXPECT_EQ(Completions.CompletionRange, Annotations(NoCompletion).range());
}
EXPECT_THAT(Conf.Index.External.MountPoint, FooPath);
// None defaults to ".".
- Frag = GetFrag(FooPath, llvm::None);
+ Frag = GetFrag(FooPath, std::nullopt);
compileAndApply();
ASSERT_THAT(Diags.Diagnostics, IsEmpty());
ASSERT_EQ(Conf.Index.External.Kind, Config::ExternalIndexSpec::File);
"Entry, or Flow Mapping End."),
diagKind(llvm::SourceMgr::DK_Error),
diagPos(YAML.point("unexpected")),
- diagRange(llvm::None))));
+ diagRange(std::nullopt))));
ASSERT_EQ(Results.size(), 1u); // invalid fragment discarded.
EXPECT_THAT(Results.front().CompileFlags.Add, ElementsAre(val("first")));
diagPos(YAML.range("diagrange").start),
diagRange(YAML.range("diagrange")))));
ASSERT_EQ(Results.size(), 1u);
- EXPECT_THAT(Results[0].Completion.AllScopes, testing::Eq(llvm::None));
+ EXPECT_THAT(Results[0].Completion.AllScopes, testing::Eq(std::nullopt));
}
TEST(ParseYAML, ShowAKA) {
ASSERT_EQ(Results.size(), 1u);
EXPECT_THAT(Results[0].InlayHints.Enabled, llvm::ValueIs(val(false)));
EXPECT_THAT(Results[0].InlayHints.ParameterNames, llvm::ValueIs(val(true)));
- EXPECT_EQ(Results[0].InlayHints.DeducedTypes, llvm::None);
+ EXPECT_EQ(Results[0].InlayHints.DeducedTypes, std::nullopt);
}
TEST(ParseYAML, IncludesIgnoreHeader) {
auto IntPtrTy = *OpaqueType::fromType(astCtx(), typeOf("int_ptr_"));
EXPECT_EQ(fromCompletionResult(decl("returns_not_dependent")), IntPtrTy);
- EXPECT_EQ(fromCompletionResult(decl("returns_dependent")), llvm::None);
+ EXPECT_EQ(fromCompletionResult(decl("returns_dependent")), std::nullopt);
EXPECT_EQ(fromCompletionResult(decl("var_not_dependent")), IntPtrTy);
- EXPECT_EQ(fromCompletionResult(decl("var_dependent")), llvm::None);
+ EXPECT_EQ(fromCompletionResult(decl("var_dependent")), std::nullopt);
}
} // namespace
for (char C : "[]")
Word.erase(std::remove(Word.begin(), Word.end(), C), Word.end());
if (Word.size() == Annotated->size())
- Annotated = llvm::None;
+ Annotated = std::nullopt;
}
bool accepts(llvm::StringRef ActualAnnotated) const {
return !Annotated || ActualAnnotated == *Annotated;
getCompileCommand(llvm::StringRef File) const override {
if (File == testPath("foo.cc"))
return cmd(File, "-DA=1");
- return None;
+ return std::nullopt;
}
tooling::CompileCommand
OverlayCDB CDB(Base.get());
EXPECT_THAT(CDB.getCompileCommand(testPath("foo.cc"))->CommandLine,
AllOf(Contains(testPath("foo.cc")), Contains("-DA=1")));
- EXPECT_EQ(CDB.getCompileCommand(testPath("missing.cc")), llvm::None);
+ EXPECT_EQ(CDB.getCompileCommand(testPath("missing.cc")), std::nullopt);
auto Override = cmd(testPath("foo.cc"), "-DA=3");
CDB.setCompileCommand(testPath("foo.cc"), Override);
EXPECT_THAT(CDB.getCompileCommand(testPath("foo.cc"))->CommandLine,
Contains("-DA=3"));
- EXPECT_EQ(CDB.getCompileCommand(testPath("missing.cc")), llvm::None);
+ EXPECT_EQ(CDB.getCompileCommand(testPath("missing.cc")), std::nullopt);
CDB.setCompileCommand(testPath("missing.cc"), Override);
EXPECT_THAT(CDB.getCompileCommand(testPath("missing.cc"))->CommandLine,
Contains("-DA=3"));
TEST_F(OverlayCDBTest, NoBase) {
OverlayCDB CDB(nullptr, {"-DA=6"});
- EXPECT_EQ(CDB.getCompileCommand(testPath("bar.cc")), None);
+ EXPECT_EQ(CDB.getCompileCommand(testPath("bar.cc")), std::nullopt);
auto Override = cmd(testPath("bar.cc"), "-DA=5");
CDB.setCompileCommand(testPath("bar.cc"), Override);
EXPECT_THAT(CDB.getCompileCommand(testPath("bar.cc"))->CommandLine,
Inner.setCompileCommand("A.cpp", tooling::CompileCommand());
Outer.setCompileCommand("B.cpp", tooling::CompileCommand());
- Inner.setCompileCommand("A.cpp", llvm::None);
- Outer.setCompileCommand("C.cpp", llvm::None);
+ Inner.setCompileCommand("A.cpp", std::nullopt);
+ Outer.setCompileCommand("C.cpp", std::nullopt);
EXPECT_THAT(Changes, ElementsAre(ElementsAre("A.cpp"), ElementsAre("B.cpp"),
ElementsAre("A.cpp"), ElementsAre("C.cpp")));
}
FS.Files[FooH];
FS.Files[Invalid];
Optional<Path> PathResult =
- getCorrespondingHeaderOrSource(FooCpp, FS.view(llvm::None));
+ getCorrespondingHeaderOrSource(FooCpp, FS.view(std::nullopt));
EXPECT_TRUE(PathResult.has_value());
ASSERT_EQ(PathResult.value(), FooH);
- PathResult = getCorrespondingHeaderOrSource(FooH, FS.view(llvm::None));
+ PathResult = getCorrespondingHeaderOrSource(FooH, FS.view(std::nullopt));
EXPECT_TRUE(PathResult.has_value());
ASSERT_EQ(PathResult.value(), FooCpp);
FS.Files[FooC];
FS.Files[FooHH];
- PathResult = getCorrespondingHeaderOrSource(FooC, FS.view(llvm::None));
+ PathResult = getCorrespondingHeaderOrSource(FooC, FS.view(std::nullopt));
EXPECT_TRUE(PathResult.has_value());
ASSERT_EQ(PathResult.value(), FooHH);
auto Foo2HH = testPath("foo2.HH");
FS.Files[Foo2C];
FS.Files[Foo2HH];
- PathResult = getCorrespondingHeaderOrSource(Foo2C, FS.view(llvm::None));
+ PathResult = getCorrespondingHeaderOrSource(Foo2C, FS.view(std::nullopt));
EXPECT_TRUE(PathResult.has_value());
ASSERT_EQ(PathResult.value(), Foo2HH);
FS.Files[Foo3C];
FS.Files[Foo3HXX];
- PathResult = getCorrespondingHeaderOrSource(Foo3C, FS.view(llvm::None));
+ PathResult = getCorrespondingHeaderOrSource(Foo3C, FS.view(std::nullopt));
EXPECT_TRUE(PathResult.has_value());
ASSERT_EQ(PathResult.value(), Foo3HXX);
// Test if asking for a corresponding file that doesn't exist returns an empty
// string.
- PathResult = getCorrespondingHeaderOrSource(Invalid, FS.view(llvm::None));
+ PathResult = getCorrespondingHeaderOrSource(Invalid, FS.view(std::nullopt));
EXPECT_FALSE(PathResult.has_value());
}
llvm::StringRef HeaderCode;
llvm::Optional<std::string> ExpectedSource;
} TestCases[] = {
- {"// empty, no header found", llvm::None},
+ {"// empty, no header found", std::nullopt},
{R"cpp(
// no definition found in the index.
void NonDefinition();
)cpp",
- llvm::None},
+ std::nullopt},
{R"cpp(
void A_Sym1();
)cpp",
)cpp",
testPath("a.cpp")},
- {R"cpp(
+ {R"cpp(
// We don't have definition in the index, so stay in the header.
void B_Sym3_NoDef();
)cpp",
- None},
+ std::nullopt},
};
for (const auto &Case : TestCases) {
TestTU TU = TestTU::withCode(Case.HeaderCode);
llvm::StringRef SourceCode;
llvm::Optional<std::string> ExpectedResult;
} TestCases[] = {
- {"// empty, no header found", llvm::None},
+ {"// empty, no header found", std::nullopt},
{R"cpp(
// symbol not in index, no header found
void Local() {}
)cpp",
- llvm::None},
+ std::nullopt},
{R"cpp(
// a.h wins.
EXPECT_EQ(Inserter.shouldInsertInclude(HeaderPath, Verbatim), true);
EXPECT_EQ(Inserter.calculateIncludePath(Inserting, "sub2/main2.cpp"),
- llvm::None);
+ std::nullopt);
}
TEST_F(HeadersTest, PresumedLocations) {
HI.TemplateParameters = {
{{"template <typename, bool...> class"},
std::string("C"),
- llvm::None},
- {{"typename"}, llvm::None, std::string("char")},
- {{"int"}, llvm::None, std::string("0")},
+ std::nullopt},
+ {{"typename"}, std::nullopt, std::string("char")},
+ {{"int"}, std::nullopt, std::string("0")},
{{"bool"}, std::string("Q"), std::string("false")},
- {{"class..."}, std::string("Ts"), llvm::None},
+ {{"class..."}, std::string("Ts"), std::nullopt},
};
}},
// Function template
HI.ReturnType = "Foo<bool, true, false>";
HI.Type = "Foo<bool, true, false> (int, bool)";
HI.Parameters = {
- {{"int"}, llvm::None, llvm::None},
+ {{"int"}, std::nullopt, std::nullopt},
{{"bool"}, std::string("T"), std::string("false")},
};
}},
HI.Type = "(lambda) **";
HI.ReturnType = "bool";
HI.Parameters = {
- {{"int"}, std::string("T"), llvm::None},
- {{"bool"}, std::string("B"), llvm::None},
+ {{"int"}, std::string("T"), std::nullopt},
+ {{"bool"}, std::string("B"), std::nullopt},
};
return HI;
}},
HI.Type = {"decltype(lamb) &", "(lambda) &"};
HI.ReturnType = "bool";
HI.Parameters = {
- {{"int"}, std::string("T"), llvm::None},
- {{"bool"}, std::string("B"), llvm::None},
+ {{"int"}, std::string("T"), std::nullopt},
+ {{"bool"}, std::string("B"), std::nullopt},
};
return HI;
}},
HI.Type = "class (lambda)";
HI.ReturnType = "bool";
HI.Parameters = {
- {{"int"}, std::string("T"), llvm::None},
- {{"bool"}, std::string("B"), llvm::None},
+ {{"int"}, std::string("T"), std::nullopt},
+ {{"bool"}, std::string("B"), std::nullopt},
};
HI.Value = "false";
return HI;
HI.Type = "class (lambda)";
HI.ReturnType = "bool";
HI.Parameters = {
- {{"int"}, std::string("T"), llvm::None},
- {{"bool"}, std::string("B"), llvm::None},
+ {{"int"}, std::string("T"), std::nullopt},
+ {{"bool"}, std::string("B"), std::nullopt},
};
return HI;
}},
HI.Type = {"m_int[Size]", "int[Size]"};
HI.NamespaceScope = "";
HI.Definition = "template <int Size> m_int arr[Size]";
- HI.TemplateParameters = {{{"int"}, {"Size"}, llvm::None}};
+ HI.TemplateParameters = {{{"int"}, {"Size"}, std::nullopt}};
}},
{// Var template decl specialization
R"cpp(
HI.Definition = "template <typename T> void foo(T arg)";
HI.Type = "void (T)";
HI.ReturnType = "void";
- HI.Parameters = {{{"T"}, std::string("arg"), llvm::None}};
- HI.TemplateParameters = {{{"typename"}, std::string("T"), llvm::None}};
+ HI.Parameters = {{{"T"}, std::string("arg"), std::nullopt}};
+ HI.TemplateParameters = {
+ {{"typename"}, std::string("T"), std::nullopt}};
}},
{// TypeAlias Template
R"cpp(
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "template <typename T> using alias = T";
HI.Type = "T";
- HI.TemplateParameters = {{{"typename"}, std::string("T"), llvm::None}};
+ HI.TemplateParameters = {
+ {{"typename"}, std::string("T"), std::nullopt}};
}},
{// TypeAlias Template
R"cpp(
HI.Kind = index::SymbolKind::TypeAlias;
HI.Definition = "template <typename T> using AA = A<T>";
HI.Type = {"A<T>", "type-parameter-0-0"}; // FIXME: should be 'T'
- HI.TemplateParameters = {{{"typename"}, std::string("T"), llvm::None}};
+ HI.TemplateParameters = {
+ {{"typename"}, std::string("T"), std::nullopt}};
}},
{// Constant array
R"cpp(
HI.Documentation = "Function definition via pointer";
HI.ReturnType = "void";
HI.Parameters = {
- {{"int"}, llvm::None, llvm::None},
+ {{"int"}, std::nullopt, std::nullopt},
};
}},
{
HI.Documentation = "Function declaration via call";
HI.ReturnType = "int";
HI.Parameters = {
- {{"int"}, llvm::None, llvm::None},
+ {{"int"}, std::nullopt, std::nullopt},
};
}},
{
HI.Type = {"auto (decltype(a)) -> decltype(a)",
"auto (int) -> int"};
HI.ReturnType = "int";
- HI.Parameters = {{{"int"}, std::string("x"), llvm::None}};
+ HI.Parameters = {{{"int"}, std::string("x"), std::nullopt}};
}},
{
R"cpp(// sizeof expr
HI.Kind = index::SymbolKind::Function;
HI.Type = "void (const int &)";
HI.ReturnType = "void";
- HI.Parameters = {{{"const int &"}, llvm::None, std::string("T()")}};
+ HI.Parameters = {
+ {{"const int &"}, std::nullopt, std::string("T()")}};
HI.Definition = "template <> void foo<int>(const int &)";
HI.NamespaceScope = "";
}},
HI.Kind = index::SymbolKind::Class;
HI.Size = 10;
HI.TemplateParameters = {
- {{"typename"}, std::string("T"), llvm::None},
+ {{"typename"}, std::string("T"), std::nullopt},
{{"typename"}, std::string("C"), std::string("bool")},
};
HI.Documentation = "documentation";
AST = Test.build();
Dyn.updateMain(testPath(Test.Filename), AST);
- Request.Limit = llvm::None;
+ Request.Limit = std::nullopt;
RefSlab::Builder Results3;
EXPECT_FALSE(
Merge.refs(Request, [&](const Ref &O) { Results3.insert(Foo.ID, O); }));
std::vector<InlayHint> hintsOfKind(ParsedAST &AST, InlayHintKind Kind) {
std::vector<InlayHint> Result;
- for (auto &Hint : inlayHints(AST, /*RestrictRange=*/llvm::None)) {
+ for (auto &Hint : inlayHints(AST, /*RestrictRange=*/std::nullopt)) {
if (Hint.kind == Kind)
Result.push_back(Hint);
}
// Sneak in a cross-cutting check that hints are disabled by config.
// We'll hit an assertion failure if addInlayHint still gets called.
WithContextValue WithCfg(Config::Key, noHintsConfig());
- EXPECT_THAT(inlayHints(AST, llvm::None), IsEmpty());
+ EXPECT_THAT(inlayHints(AST, std::nullopt), IsEmpty());
}
// Hack to allow expression-statements operating on parameter packs in C++14.
auto BaselinePreamble = TestTU::withCode(Baseline).preamble();
if (!BaselinePreamble) {
ADD_FAILURE() << "Failed to build baseline preamble";
- return llvm::None;
+ return std::nullopt;
}
IgnoreDiagnostics Diags;
auto CI = buildCompilerInvocation(TU.inputs(FS), Diags);
if (!CI) {
ADD_FAILURE() << "Failed to build compiler invocation";
- return llvm::None;
+ return std::nullopt;
}
return ParsedAST::build(testPath(TU.Filename), TU.inputs(FS), std::move(CI),
{}, BaselinePreamble);
runAddDocument(Server, FooCCPath, FooCC.code());
auto Results = runPrepareRename(Server, FooCCPath, FooCC.point(),
- /*NewName=*/llvm::None, {});
+ /*NewName=*/std::nullopt, {});
// Verify that for multi-file rename, we only return main-file occurrences.
ASSERT_TRUE(bool(Results)) << Results.takeError();
// We don't know the result is complete in prepareRename (passing a nullptr
const NamedDecl &Decl = findUnqualifiedDecl(AST, Name);
auto FileRange = toHalfOpenFileRange(SM, LangOpts, Decl.getSourceRange());
SCOPED_TRACE("Checking range: " + Name);
- ASSERT_NE(FileRange, llvm::None);
+ ASSERT_NE(FileRange, std::nullopt);
Range HalfOpenRange = SourceRangeToRange(*FileRange);
EXPECT_EQ(HalfOpenRange, Test.ranges(Name)[0]);
};
auto Add = [&](const LangOptions &LO,
std::vector<llvm::StringRef> SearchPath) {
SourceManagerForFile SM("scratch", "");
- SM.get().getFileManager().setVirtualFileSystem(FS.view(llvm::None));
+ SM.get().getFileManager().setVirtualFileSystem(FS.view(std::nullopt));
HeaderSearch HS(/*HSOpts=*/nullptr, SM.get(), SM.get().getDiagnostics(), LO,
/*Target=*/nullptr);
for (auto P : SearchPath)
return Ref;
}
}
- return llvm::None;
+ return std::nullopt;
};
auto Container = [&](llvm::StringRef RangeName) {
auto Ref = FindRefWithRange(Code.range(RangeName));
llvm::Optional<tooling::CompileCommand>
getCompileCommand(PathRef File) const override {
if (File == NoCmd || File == NotIncluded || FailAll)
- return llvm::None;
+ return std::nullopt;
auto Basic = getFallbackCommand(File);
Basic.Heuristic.clear();
if (File == Unreliable) {
llvm::Optional<tooling::CompileCommand>
MockCompilationDatabase::getCompileCommand(PathRef File) const {
if (ExtraClangFlags.empty())
- return None;
+ return std::nullopt;
auto FileName = llvm::sys::path::filename(File);
auto It = Inputs.find(Filename);
if (It == Inputs.end()) {
ADD_FAILURE() << "Accessing non-existing file: " << Filename;
- return llvm::None;
+ return std::nullopt;
}
TU.Code = It->second.Code;
TU.Filename = It->first().str();
TestTU TU = TestTU::withCode(Code.code());
auto AST = TU.build();
EXPECT_THAT(locateSymbolAt(AST, Code.point(), TU.index().get()),
- UnorderedElementsAre(sym("foo", Code.range("1"), llvm::None),
- sym("foo", Code.range("2"), llvm::None)));
+ UnorderedElementsAre(sym("foo", Code.range("1"), std::nullopt),
+ sym("foo", Code.range("2"), std::nullopt)));
}
TEST(LocateSymbol, WithIndexPreferredLocation) {
// FIXME: Target the constructor as well.
EXPECT_THAT(locateSymbolAt(AST, T.point("9")), ElementsAre(sym("Foo")));
EXPECT_THAT(locateSymbolAt(AST, T.point("10")),
- ElementsAre(sym("Foo", T.range("ConstructorLoc"), llvm::None)));
+ ElementsAre(sym("Foo", T.range("ConstructorLoc"), std::nullopt)));
EXPECT_THAT(locateSymbolAt(AST, T.point("11")),
- ElementsAre(sym("Foo", T.range("ConstructorLoc"), llvm::None)));
+ ElementsAre(sym("Foo", T.range("ConstructorLoc"), std::nullopt)));
// These assertions are unordered because the order comes from
// CXXRecordDecl::lookupDependentName() which doesn't appear to provide
// an order guarantee.
EXPECT_THAT(locateSymbolAt(AST, T.point("12")),
UnorderedElementsAre(
- sym("bar", T.range("NonstaticOverload1"), llvm::None),
- sym("bar", T.range("NonstaticOverload2"), llvm::None)));
- EXPECT_THAT(
- locateSymbolAt(AST, T.point("13")),
- UnorderedElementsAre(sym("baz", T.range("StaticOverload1"), llvm::None),
- sym("baz", T.range("StaticOverload2"), llvm::None)));
+ sym("bar", T.range("NonstaticOverload1"), std::nullopt),
+ sym("bar", T.range("NonstaticOverload2"), std::nullopt)));
+ EXPECT_THAT(locateSymbolAt(AST, T.point("13")),
+ UnorderedElementsAre(
+ sym("baz", T.range("StaticOverload1"), std::nullopt),
+ sym("baz", T.range("StaticOverload2"), std::nullopt)));
}
TEST(LocateSymbol, TextualDependent) {
// interaction between locateASTReferent() and
// locateSymbolNamedTextuallyAt().
auto Results = locateSymbolAt(AST, Source.point(), Index.get());
- EXPECT_THAT(Results,
- UnorderedElementsAre(
- sym("uniqueMethodName", Header.range("FooLoc"), llvm::None),
- sym("uniqueMethodName", Header.range("BarLoc"), llvm::None)));
+ EXPECT_THAT(
+ Results,
+ UnorderedElementsAre(
+ sym("uniqueMethodName", Header.range("FooLoc"), std::nullopt),
+ sym("uniqueMethodName", Header.range("BarLoc"), std::nullopt)));
}
TEST(LocateSymbol, Alias) {
// stale one.
EXPECT_THAT(
cantFail(runLocateSymbolAt(Server, FooCpp, FooWithoutHeader.point())),
- ElementsAre(sym("foo", FooWithoutHeader.range(), llvm::None)));
+ ElementsAre(sym("foo", FooWithoutHeader.range(), std::nullopt)));
// Reset test environment.
runAddDocument(Server, FooCpp, FooWithHeader.code());
// Use the AST being built in above request.
EXPECT_THAT(
cantFail(runLocateSymbolAt(Server, FooCpp, FooWithoutHeader.point())),
- ElementsAre(sym("foo", FooWithoutHeader.range(), llvm::None)));
+ ElementsAre(sym("foo", FooWithoutHeader.range(), std::nullopt)));
}
TEST(LocateSymbol, NearbyTokenSmoke) {
Nearby = halfOpenToRange(SM, CharSourceRange::getCharRange(
Tok->location(), Tok->endLocation()));
if (T.ranges().empty())
- EXPECT_THAT(Nearby, Eq(llvm::None)) << Test;
+ EXPECT_THAT(Nearby, Eq(std::nullopt)) << Test;
else
EXPECT_EQ(Nearby, T.range()) << Test;
}
EXPECT_THAT(
findImplementations(AST, Code.point(), TU.index().get()),
UnorderedElementsAre(sym("Foo", Code.range("Decl"), Code.range("Def")),
- sym("Foo", Code.range("Child2"), llvm::None)))
+ sym("Foo", Code.range("Child2"), std::nullopt)))
<< Test;
}
auto AST = TestTU::withCode(File.code()).build();
findReferences(AST, File.point(), 0, &Rec);
if (T.WantQuery)
- EXPECT_NE(Rec.RefIDs, None) << T.AnnotatedCode;
+ EXPECT_NE(Rec.RefIDs, std::nullopt) << T.AnnotatedCode;
else
- EXPECT_EQ(Rec.RefIDs, None) << T.AnnotatedCode;
+ EXPECT_EQ(Rec.RefIDs, std::nullopt) << T.AnnotatedCode;
}
}
B.Reduce[StateID{2}].insert(RuleID{1});
LRTable T = std::move(B).build();
- EXPECT_EQ(T.getShiftState(0, Eof), llvm::None);
+ EXPECT_EQ(T.getShiftState(0, Eof), std::nullopt);
EXPECT_THAT(T.getShiftState(0, Identifier), ValueIs(0));
EXPECT_THAT(T.getReduceRules(0), ElementsAre(0));
- EXPECT_EQ(T.getShiftState(1, Eof), llvm::None);
- EXPECT_EQ(T.getShiftState(1, Identifier), llvm::None);
+ EXPECT_EQ(T.getShiftState(1, Eof), std::nullopt);
+ EXPECT_EQ(T.getShiftState(1, Identifier), std::nullopt);
EXPECT_THAT(T.getGoToState(1, Term), ValueIs(3));
EXPECT_THAT(T.getReduceRules(1), ElementsAre(2));
// Verify the behaivor for other non-available-actions terminals.
SymbolID Int = tokenSymbol(tok::kw_int);
- EXPECT_EQ(T.getShiftState(2, Int), llvm::None);
+ EXPECT_EQ(T.getShiftState(2, Int), std::nullopt);
// Check follow sets.
EXPECT_TRUE(T.canFollow(Term, Plus));
std::string
runCheckOnCode(StringRef Code, std::vector<ClangTidyError> *Errors = nullptr,
const Twine &Filename = "input.cc",
- ArrayRef<std::string> ExtraArgs = None,
+ ArrayRef<std::string> ExtraArgs = std::nullopt,
const ClangTidyOptions &ExtraOptions = ClangTidyOptions(),
std::map<StringRef, StringRef> PathsToContent =
std::map<StringRef, StringRef>()) {
template <typename Check>
std::string runCheckOnCode(StringRef Code, StringRef Filename) {
std::vector<ClangTidyError> Errors;
- return test::runCheckOnCode<Check>(Code, &Errors, Filename, None,
+ return test::runCheckOnCode<Check>(Code, &Errors, Filename, std::nullopt,
ClangTidyOptions(),
{// Main file include
{"clang_tidy/tests/"
runHeaderGuardCheck("#ifndef LLVM_ADT_FOO_H_\n"
"#define LLVM_ADT_FOO_H_\n"
"#endif\n",
- "include/llvm/ADT/foo.h", None));
+ "include/llvm/ADT/foo.h", std::nullopt));
EXPECT_EQ("#ifndef LLVM_CLANG_C_BAR_H\n"
"#define LLVM_CLANG_C_BAR_H\n"
runHeaderGuardCheckWithEndif("#ifndef LLVM_ADT_FOO_H\n"
"#define LLVM_ADT_FOO_H\n"
"#endif /* LLVM_ADT_FOO_H */\n",
- "include/llvm/ADT/foo.h", None));
+ "include/llvm/ADT/foo.h",
+ std::nullopt));
EXPECT_EQ("#ifndef LLVM_ADT_FOO_H_\n"
"#define LLVM_ADT_FOO_H_\n"
runHeaderGuardCheckWithEndif("#ifndef LLVM_ADT_FOO_H_\n"
"#define LLVM_ADT_FOO_H_\n"
"#endif // LLVM_ADT_FOO_H_\n",
- "include/llvm/ADT/foo.h", None));
+ "include/llvm/ADT/foo.h",
+ std::nullopt));
EXPECT_EQ("#ifndef LLVM_ADT_FOO_H\n"
"#define LLVM_ADT_FOO_H\n"
"#define LLVM_ADT_FOO_H\n"
"#endif // LLVM_ADT_FOO_H\n";
EXPECT_EQ(WithExtraSpace,
- runHeaderGuardCheckWithEndif(WithExtraSpace,
- "include/llvm/ADT/foo.h", None));
+ runHeaderGuardCheckWithEndif(
+ WithExtraSpace, "include/llvm/ADT/foo.h", std::nullopt));
EXPECT_EQ("#ifndef LLVM_ADT_FOO_H\n"
"#define LLVM_ADT_FOO_H\n"
"#define LLVM_ADT_FOO_H\n"
"#endif /* LLVM_ADT_FOO_H\\ \n"
" FOO */",
- "include/llvm/ADT/foo.h", None));
+ "include/llvm/ADT/foo.h",
+ std::nullopt));
EXPECT_EQ("#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_FOO_H\n"
"#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_FOO_H\n"
std::vector<ClangTidyError> errors;
std::string result =
- test::runCheckOnCode<Check>(Code, &errors, "foo.cc", None,
+ test::runCheckOnCode<Check>(Code, &errors, "foo.cc", std::nullopt,
ClangTidyOptions(), AdditionalFileContents);
EXPECT_EQ(ExpectedWarningCount, errors.size());
" else if (1 == 2) return -2;\n"
" else return -3;\n"
"}",
- nullptr, "input.cc", None, Options));
+ nullptr, "input.cc", std::nullopt, Options));
// If the last else is an else-if, we also force it.
EXPECT_EQ("int main() {\n"
" if (false) return -1;\n"
" else if (1 == 2) return -2;\n"
"}",
- nullptr, "input.cc", None, Options));
+ nullptr, "input.cc", std::nullopt, Options));
}
TEST(BracesAroundStatementsCheckTest, For) {
needsObjC(const LangOptions &LangOpts,
const ClangTidyCheck::OptionsView &Options) {
if (!LangOpts.ObjC)
- return None;
+ return std::nullopt;
return makeRule(clang::ast_matchers::functionDecl(),
change(cat("void changed() {}")), cat("no message"));
}
noSkip(const LangOptions &LangOpts,
const ClangTidyCheck::OptionsView &Options) {
if (Options.get("Skip", "false") == "true")
- return None;
+ return std::nullopt;
return makeRule(clang::ast_matchers::functionDecl(),
changeTo(cat("void nothing();")), cat("no message"));
}
Options.CheckOptions["test-check-0.Skip"] = "true";
EXPECT_EQ(Input, test::runCheckOnCode<ConfigurableCheck>(
- Input, nullptr, "input.cc", None, Options));
+ Input, nullptr, "input.cc", std::nullopt, Options));
Options.CheckOptions["test-check-0.Skip"] = "false";
EXPECT_EQ(Expected, test::runCheckOnCode<ConfigurableCheck>(
- Input, nullptr, "input.cc", None, Options));
+ Input, nullptr, "input.cc", std::nullopt, Options));
}
RewriteRuleWith<std::string> replaceCall(IncludeFormat Format) {
std::map<StringRef, StringRef> PathsToContent = {{"input.h", "\n"}};
Options.CheckOptions["test-check-0.IncludeStyle"] = "llvm";
EXPECT_EQ(TreatsAsLibraryHeader, test::runCheckOnCode<IncludeOrderCheck>(
- Input, nullptr, "inputTest.cpp", None,
- Options, PathsToContent));
+ Input, nullptr, "inputTest.cpp",
+ std::nullopt, Options, PathsToContent));
EXPECT_EQ(TreatsAsNormalHeader, test::runCheckOnCode<IncludeOrderCheck>(
- Input, nullptr, "input_test.cpp", None,
- Options, PathsToContent));
+ Input, nullptr, "input_test.cpp",
+ std::nullopt, Options, PathsToContent));
Options.CheckOptions["test-check-0.IncludeStyle"] = "google";
- EXPECT_EQ(TreatsAsNormalHeader,
- test::runCheckOnCode<IncludeOrderCheck>(
- Input, nullptr, "inputTest.cc", None, Options, PathsToContent));
+ EXPECT_EQ(TreatsAsNormalHeader, test::runCheckOnCode<IncludeOrderCheck>(
+ Input, nullptr, "inputTest.cc",
+ std::nullopt, Options, PathsToContent));
EXPECT_EQ(TreatsAsLibraryHeader, test::runCheckOnCode<IncludeOrderCheck>(
- Input, nullptr, "input_test.cc", None,
- Options, PathsToContent));
+ Input, nullptr, "input_test.cc",
+ std::nullopt, Options, PathsToContent));
}
TEST(TransformerClangTidyCheckTest, AddIncludeObeysSortStyleGlobalOption) {
std::map<StringRef, StringRef> PathsToContent = {{"input.h", "\n"}};
Options.CheckOptions["IncludeStyle"] = "llvm";
EXPECT_EQ(TreatsAsLibraryHeader, test::runCheckOnCode<IncludeOrderCheck>(
- Input, nullptr, "inputTest.cpp", None,
- Options, PathsToContent));
+ Input, nullptr, "inputTest.cpp",
+ std::nullopt, Options, PathsToContent));
EXPECT_EQ(TreatsAsNormalHeader, test::runCheckOnCode<IncludeOrderCheck>(
- Input, nullptr, "input_test.cpp", None,
- Options, PathsToContent));
+ Input, nullptr, "input_test.cpp",
+ std::nullopt, Options, PathsToContent));
Options.CheckOptions["IncludeStyle"] = "google";
- EXPECT_EQ(TreatsAsNormalHeader,
- test::runCheckOnCode<IncludeOrderCheck>(
- Input, nullptr, "inputTest.cc", None, Options, PathsToContent));
+ EXPECT_EQ(TreatsAsNormalHeader, test::runCheckOnCode<IncludeOrderCheck>(
+ Input, nullptr, "inputTest.cc",
+ std::nullopt, Options, PathsToContent));
EXPECT_EQ(TreatsAsLibraryHeader, test::runCheckOnCode<IncludeOrderCheck>(
- Input, nullptr, "input_test.cc", None,
- Options, PathsToContent));
+ Input, nullptr, "input_test.cc",
+ std::nullopt, Options, PathsToContent));
}
} // namespace
std::vector<ClangTidyError> errors;
std::string result =
- test::runCheckOnCode<Check>(Code, &errors, "foo.cc", None,
+ test::runCheckOnCode<Check>(Code, &errors, "foo.cc", std::nullopt,
ClangTidyOptions(), AdditionalFileContents);
EXPECT_EQ(ExpectedWarningCount, errors.size());